{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import bvhsdk\n",
    "import ik\n",
    "import mathutils\n",
    "import skeletonmap\n",
    "import surface\n",
    "import plotanimation\n",
    "import egocentriccoord\n",
    "import numpy as np\n",
    "import os\n",
    "import time\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.animation import FuncAnimation\n",
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Abstract\n",
    "\n",
    "(em construção)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "Toy Story was released in 1995 as the first full length film produced entirely through computer animation techniques<cite data-cite=\"henne\"></cite>. Besides Pixar's production, several applications employ digital animations to entertain, convey information, educate, among others. Some exploits the use of virtual human models to make the human-computer interatction more natural and accessible. Talita, the virtual human of the TAS project<cite data-cite=\"demartino\"></cite>, is a signing avatar that communicates with deaf students using the Brazilian Sign Language. The goal of the TAS project is to help the deaf and hard of hearing to access information and in their educational process.\n",
    "\n",
    "Humans uses not only the voice and facial expression cues to understand intentions, motives and wills, but also the movements of our body and limbs may carry semantic information on the emotion that one is triyng to express. The location, orientation and speed of the hand are some of the parameters that characterizes a sign language gesture, slightly discrepancies will express different messages or even make the gesture unrecognizable. Therefore, an accurate motion representation by the virtual agent should be of great concern.\n",
    "\n",
    "Keyframing is a technique to animate an avatar, the animator adjusts crucial poses of the 3D character on dispersed frames and an algorithm fills the gap between two poses by interpolating them over time, which creates the impression of the desired motion. Another digital animation technique is Motion Capture (MoCap) that aims to lessen the time-consuming and tedious work of keyframing animations. MoCap systems registers an actor performing the desired motion to animate a 3D character. Optical Motion Capture systems, for example, uses a set of cameras to track the position over time of reflective markers placed on the body surface of the performer. The motion is then transferred to the avatar, the motion retargeting process, without the need to create all the poses along the action.\n",
    "\n",
    "The motion retargeting, however, can cause ill-conditioned poses when the body proportions of the performer and the avatar are different. The motion retargeting of an actor with long arms covering his ears, as an example, to a 3D character with short arms results in a unrecognizable action, since the hands of the avatar will not reach its ears. In this case, the animator must inspect the animation, identify the irregular artifacts and correct them with keyframing, adjusting the avatar pose to the desired one. Some motion retargeting algorithms aims to avoid such artifacts to further reduce the inspection and adjustments needed by the animator.\n",
    "\n",
    "Furtheremore, the standard approach to animate 3D characters is the skeleton animation. The skeleton, a hierarchical structure of joints and bones, stores the actual motion data and the surface of the character is deformed accordingly to the rotation and translation of the skeleton. Often MoCap systems, game engines, 3D modeling and animation software built the skeleton with different specifications(cite Kitagawa), i.e., distinct topologies of the hierarchical structure. This complicates the motion retargeting process because the joints and bones of one skeleton may not exist in another or be represented in another way.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Related Works\n",
    "\n",
    "(em construção)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Workflow\n",
    "![Workflow](../figures/Workflow3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initial Retargeting\n",
    "\n",
    "## Skeleton Animation\n",
    "This chapter describes the Initial Motion Retargeting process, which receives the source animation and the target skeleton as inputs, both BVH files. The output is an animation of the target skeleton performing the movements of the source skeleton that can be exported as a BVH file. The success of the process does not depend on matching topologies of the skeletons, but the first pose of the source animation and the target skeleton pose must be as close as possible to the T-Pose. The output of the Initial Retargeting is the target skeleton animation. The target animation does not exploit yet the “surface-awareness” adjustments that the methods described in the subsequent sections provide, but it can already be imported in game engines or animation softwares to animate a 3D character.\n",
    "\n",
    "\n",
    "To animate a skeleton, its joints must rotate and translate along the frames, conveying the impression of motion. The hierarchical representation of the skeleton allows an all-around description of the motion by only preserving the rotational and translational values of a joint regarding its parent joint, i.e., local rotations and translations. The local transform matrix $M$ is the combination of both rotation $R$ and translation matrix $T$:\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:transformmatrix}\n",
    "M = TR = \\begin{bmatrix}\n",
    "    R_{3x3} & T \\\\\n",
    "    0 & 1\n",
    "    \\end{bmatrix}\n",
    "\\end{equation}\n",
    "\n",
    "Given a joint $n$ in the skeleton, its global transform matrix $M_{global}^{n}$ is the combination of the local transform matrices of all the joints above the hierarchy. The position of the joint is computed through the global transform matrix.\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:transformmatrixglobal}\n",
    "M_{global}^{n} = \\prod_{i=0}^{n} M_{local}^{i}\n",
    "\\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:position}\n",
    "\\mathbf{p}_{n} = M_{global}^{n}[0,0,0,1]^T\n",
    "\\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load Source Animation (Skeleton + Motion)\n",
    "sourceAnimationPath = '..\\data\\source_animation-entender.bvh'\n",
    "sourceAnimation = bvhsdk.ReadFile(sourceAnimationPath)\n",
    "#Load Target Skeleton\n",
    "targetSkeleton = '..\\\\data\\\\target_skeleton.bvh'\n",
    "targetAnimation = bvhsdk.ReadFile(targetSkeleton)\n",
    "#Load Source Surface\n",
    "sourceSurfacePath = '..\\data\\surface_rodolfo.txt'\n",
    "sourceSurface = surface.GetMoCapSurfaceFromTXT(sourceSurfacePath, highpolymesh = False)\n",
    "#Load Target Surface\n",
    "targetSurfacePath = '..\\\\data\\\\target_surface.csv'\n",
    "targetSurface = surface.GetAvatarSurfaceFromCSV(targetSurfacePath, targetAnimation, False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PlotBVH(animation):           \n",
    "    %matplotlib qt\n",
    "    def update(frame, lines, bones):\n",
    "        for line, bone in zip(lines, range(len(lines))):\n",
    "            line.set_data([bones[frame,bone,0], bones[frame,bone,3]], [bones[frame,bone,1], bones[frame,bone,4]])\n",
    "            line.set_3d_properties([bones[frame,bone,2], bones[frame,bone,5]])\n",
    "        return lines\n",
    "\n",
    "    fig = plt.figure(figsize=(12,8))\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    #print('Preparing plot:')\n",
    "    #print('Computing Bones...')\n",
    "    #Draw Bones #######################################################\n",
    "    bones = []\n",
    "    for frame in range(animation.frames):\n",
    "        bones.append(animation.getBones(frame))\n",
    "        #if np.mod(frame+1,100) == 0:\n",
    "            #print('%i frames done.' % (int((frame+1)/100)*100))\n",
    "        \n",
    "    bones = np.asarray(bones)\n",
    "    mindata = bones.min()\n",
    "    maxdata = bones.max()\n",
    "    lines = []\n",
    "    for bone in animation.getBones(0):\n",
    "        lines.append(ax.plot([bone[0], bone[3]], [bone[1], bone[4]], [bone[2], bone[5]],'-o', color='black')[0])\n",
    "    #print('Done!')\n",
    "        \n",
    "    ax.set_xlabel('X Label')\n",
    "    ax.set_ylabel('Y Label')\n",
    "    ax.set_zlabel('Z Label')\n",
    "    ax.set_xlim(mindata,maxdata)\n",
    "    ax.set_ylim(mindata,maxdata)\n",
    "    ax.set_zlim(mindata,maxdata)\n",
    "    ani = FuncAnimation(fig, update, frames=np.arange(animation.frames), fargs=(lines, bones) ,interval=1, blit=True)\n",
    "    return ani\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot Source Animation\n",
    "#_ = PlotBVH(sourceAnimation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Skeleton Mapping\n",
    "\n",
    "Figure 2 presents two approaches to represent a virtual human skeleton. Although both can animate a humanoid-shaped model, transferring motions between the skeletons is not straightforward. A correspondence between joints of the skeletons is mandatory to identify which joints from the target skeleton should mimic the motion from the source skeleton. It is possible to infer a correspondence using the joints’ name automatically, but note that they may not be placed at the same point in the respective skeleton, as the shoulders in the figure. Therefore, the user can provide a correspondence between skeletons to properly map joints and to perform the motion retargeting (Detailed in Appendix A) (cite Monzani and Hsieh).\n",
    "\n",
    "![Skeleton Map](../figures/skelmap.png)\n",
    "\n",
    "In this work, it is required that both target and source skeletons have at least the set of joints: one hips joint, three spine joints, neck and head joints, and right and left joints for the shoulders, elbows, wrists, femurs, knees and feet. The joints referenced will be the only ones used in the Initial Retargeting proccess.\n",
    "\n",
    "## Bones Alignment\n",
    "\n",
    "Bones Alignment enforces that the vector of a mapped joint from the target skeleton pointing towards its child joint has the same direction of the correspondent vector from the source skeleton. Then, for every frame, we apply the same transform from the source skeleton joint to the correspondent target joint.\n",
    "\n",
    "The rotation matrix $R_{A}$ to align the bone vector of the target skeleton onto the bone vector of the source skeleton is calculated and applied to the global rotation of the target skeleton joint $R_{NG}^{n}$:\n",
    "\n",
    "\\begin{equation}\n",
    "        \\label{eq:newglobal}\n",
    "        R_{NG}^{n} = R_{A} R_{G}^{n}\n",
    "        \\end{equation}\n",
    "        \n",
    "Then, as expected by the BVH file format, we recover the local rotation of the joint $R_{L}^{n}$, the new global orientation is multiplied by its parent inverse rotation matrix.\n",
    "\n",
    "\\begin{equation}\n",
    "        \\label{eq:newglobal2}\n",
    "        R_{NG}^{n} = \\left(\\prod_{i=0}^{n-1} R_{L}^{i}\\right) R_{L}^{n} \n",
    "        \\end{equation}\n",
    "\n",
    "\\begin{equation}\n",
    "    \\label{eq:newglobal3}\n",
    "    R_{NG}^{n} = R_{G}^{n-1} R_{L}^{n}\n",
    "    \\end{equation}\n",
    "        \n",
    "\\begin{equation}\n",
    "    \\label{eq:newglobal4}\n",
    "    R_{L}^{n} = (R_{G}^{n-1})^{-1} R_{NG}^{n}\n",
    "    \\end{equation}\n",
    "    \n",
    "In the following frames, the rotation of a joint in the source animation, from the last frame to the current one, replaces the rotation $R_{A}$ to align the correspondent joint in the target skeleton.\n",
    "\n",
    "The source motion of the root joint is decomposed into vertical and horizontal movement that are analyzed separately. The horizontal movement is the projection of the root joint position into the ground, the reason of the decomposition is the use of this projected point as a reference point for the feet (Section Surface Characterization).\n",
    "\n",
    "The ratio is given by:\n",
    "\n",
    "\\begin{equation}\n",
    "    \\label{eq:heightratio}\n",
    "    ratio = \\frac{h_{root}^{tgt}}{h_{root}^{src}}\n",
    "    \\end{equation}\n",
    "    \n",
    "where $h_{root}^{tgt}$ and $h_{root}^{src}$ are the heights of the root joint of the target and source skeletons in the first frame. The horizontal and vertical movement of the root, $g(t)$ and $h(t)$ is computed. The translation of the root joint regarding the system origin is equal to these values recombined.\n",
    "\n",
    "\\begin{equation}\n",
    "    \\label{eq:rootmov}\n",
    "    \\mathbf{g}(t)_{root}^{src} = \\mathbf{g}(t)_{root}^{tgt} ratio \\hspace{10pt} and \\hspace{10pt}\n",
    "    \\mathbf{h}(t)_{root}^{src} = \\mathbf{h}(t)_{root}^{tgt} ratio\n",
    "    \\end{equation}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def AlignBones(target, source, headAlign = True, spineAlign = True):\n",
    "    \"\"\"\n",
    "    Align the bones of the target skeleton with the bones of the source skeleton.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    target : Animation class object\n",
    "        Input target skeleton. An Animation object with one frame. The skeleton should be in the T-Pose.\n",
    "    source : Animation class object\n",
    "        Input source animation. An Animation object that the target skeleton will copy.\n",
    "    headAlign : bool, optional\n",
    "        If this is set to True, the neck bone is aligned. This can cause strange looking pose if the skeletons have very different topologies.\n",
    "    spineAlign : bool, optional\n",
    "        If this is set to True, the spine bone is aligned. This can cause strange looking pose if the skeletons have very different topologies.\n",
    "    \"\"\"\n",
    "    #Get skeleton map\n",
    "    sourcemap = source.getskeletonmap()\n",
    "    targetmap = target.getskeletonmap()\n",
    "\n",
    "    #Save the reference TPose. The user can export the target animation with a TPose in the first frame.\n",
    "    for joint in target.getlistofjoints():\n",
    "        joint.tposerot = joint.rotation[0]\n",
    "        joint.tposetrans = joint.translation[0]\n",
    "\n",
    "    #Expand the number of frames of the avatar animation to match the mocap animation\n",
    "    target.expandFrames(sourcemap.root.translation.shape[0])\n",
    "\n",
    "    #print('Starting Posture Initialization')\n",
    "    start=time.time()\n",
    "    #Adapt pose each frame\n",
    "    for frame in range(source.frames):\n",
    "        if np.mod(frame+1,100) == 0:\n",
    "            #print('%i frames done. %.2f seconds.' % (int((frame+1)/100)*100,float(time.time()-start)))\n",
    "            start=time.time()\n",
    "\n",
    "        #Get the Height of the root in the base position (Frame = 0)\n",
    "        #The source and target animation should be in the TPose\n",
    "        if frame == 0:\n",
    "            ground_normal = np.array([0,1,0])\n",
    "            srcHHips = np.dot(sourcemap.hips.getPosition(0), ground_normal)\n",
    "            tgtHHips = np.dot(targetmap.hips.getPosition(0), ground_normal)\n",
    "            ratio = tgtHHips/srcHHips\n",
    "\n",
    "        #Adjust roots/hips height\n",
    "        srcPosHips = sourcemap.hips.getPosition(frame)\n",
    "        srcGroundHips = np.asarray([srcPosHips[0], 0, srcPosHips[2]])\n",
    "        tgtGroundHips = srcGroundHips*ratio\n",
    "        srcHHips = np.dot(sourcemap.hips.getPosition(frame), ground_normal)\n",
    "        tgtHHips = srcHHips*ratio\n",
    "        targetmap.root.translation[frame] = [0,tgtHHips,0] + tgtGroundHips\n",
    "\n",
    "        #Align the bones in the first frame because the motion capture actor may not be exactly at TPose\n",
    "        #That is, the spine could be curved, the arms may not be completly extended, etc.\n",
    "        if frame == 0:\n",
    "            #Get bones\n",
    "            srcBones, tgtBones = [], []\n",
    "            if spineAlign:\n",
    "                srcBones.append([sourcemap.hips, sourcemap.spine3])\n",
    "                tgtBones.append([targetmap.hips, targetmap.spine3])\n",
    "            if headAlign:\n",
    "                srcBones.append([sourcemap.neck, sourcemap.head])\n",
    "                tgtBones.append([targetmap.neck, targetmap.head])\n",
    "            srcBones = srcBones + [[sourcemap.rarm, sourcemap.rforearm],[sourcemap.larm, sourcemap.lforearm],[sourcemap.rforearm, sourcemap.rhand],[sourcemap.lforearm, sourcemap.lhand],[sourcemap.rupleg, sourcemap.rlowleg],[sourcemap.lupleg, sourcemap.llowleg],[sourcemap.rlowleg, sourcemap.rfoot],[sourcemap.llowleg, sourcemap.lfoot]]\n",
    "            tgtBones = tgtBones + [[targetmap.rarm, targetmap.rforearm],[targetmap.larm, targetmap.lforearm],[targetmap.rforearm, targetmap.rhand],[targetmap.lforearm, targetmap.lhand],[targetmap.rupleg, targetmap.rlowleg],[targetmap.lupleg, targetmap.llowleg],[targetmap.rlowleg, targetmap.rfoot],[targetmap.llowleg, targetmap.lfoot]]\n",
    "            for mocapbone, avabone in zip(srcBones,tgtBones):\n",
    "                #Get source and target global transform and rotation matrices from the start of the bone\n",
    "                p0 = mocapbone[0].getPosition(0)\n",
    "                p1 = mocapbone[1].getPosition(0)\n",
    "                srcDirection = mathutils.unitVector(p1-p0)\n",
    "                #Get source and target global transform and rotation matrices from the end of the bone\n",
    "                p0 = avabone[0].getPosition(0)\n",
    "                p1 = avabone[1].getPosition(0)\n",
    "                tgtDirection = mathutils.unitVector(p1-p0)\n",
    "                #Rotation matrix to align the bones\n",
    "                alignMat = mathutils.alignVectors(tgtDirection, srcDirection)\n",
    "                #Get new global rotation matrix\n",
    "                tgtGlbTransformMat = avabone[0].getGlobalTransform(frame)\n",
    "                tgtGlbRotationMat = mathutils.shape4ToShape3(tgtGlbTransformMat)\n",
    "                tgtNewGblRotationMat = np.dot(alignMat,tgtGlbRotationMat)\n",
    "                #Get new local rotation matrix\n",
    "                if not avabone[0] == targetmap.root: #Does not have a parent, transform is already local\n",
    "                    tgtParentGblRotationMat = mathutils.shape4ToShape3(avabone[0].parent.getGlobalTransform(frame))\n",
    "                    tgtNewLclRotationMat = np.dot(tgtParentGblRotationMat.T, tgtNewGblRotationMat)\n",
    "                else:\n",
    "                    tgtNewLclRotationMat = tgtNewGblRotationMat[:]\n",
    "                #Get new local rotation euler angles\n",
    "                tgtNewLclRotationEuler, warning = mathutils.eulerFromMatrix(tgtNewLclRotationMat, avabone[0].order)\n",
    "                avabone[0].rotation[frame] = tgtNewLclRotationEuler\n",
    "        else:\n",
    "            #For the rest of the motion, apply the transform of the mapped source joints in the mapped target joints\n",
    "            for tgtJoint, srcJoint in zip(targetmap.getJointsNoRootHips(), sourcemap.getJointsNoRootHips()):\n",
    "                if tgtJoint is not None and srcJoint is not None:\n",
    "                    previousframe = frame-1\n",
    "                    #Get source and target global transform and rotation matrices\n",
    "                    srcGlbTransformMat = srcJoint.getGlobalTransform(frame)\n",
    "                    srcGlbRotationMat = mathutils.shape4ToShape3(srcGlbTransformMat)\n",
    "                    tgtGlbTransformMat = tgtJoint.getGlobalTransform(previousframe)\n",
    "                    tgtGlbRotationMat = mathutils.shape4ToShape3(tgtGlbTransformMat)\n",
    "                    #Get previous source global transform and rotation matrices\n",
    "                    srcPreviousGlbTransformMat = srcJoint.getGlobalTransform(previousframe)\n",
    "                    srcPreviousGlbRotationMat = mathutils.shape4ToShape3(srcPreviousGlbTransformMat)\n",
    "                    #Get the transform of the source from the previous frame to the present frame\n",
    "                    transform = np.dot(srcGlbRotationMat, srcPreviousGlbRotationMat.T)\n",
    "                    #Apply transform\n",
    "                    tgtNewGblRotationMat = np.dot(transform, tgtGlbRotationMat)\n",
    "                    #Get new local rotation matrix\n",
    "                    tgtParentGblRotationMat = mathutils.shape4ToShape3(tgtJoint.parent.getGlobalTransform(frame))\n",
    "                    tgtNewLclRotationMat = np.dot(tgtParentGblRotationMat.T, tgtNewGblRotationMat)\n",
    "                    #Get new local rotation euler angles\n",
    "                    tgtNewLclRotationEuler, warning = mathutils.eulerFromMatrix(tgtNewLclRotationMat, tgtJoint.order)\n",
    "                    tgtJoint.rotation[frame] = tgtNewLclRotationEuler[:]\n",
    "    #Set number of frames and duration of each frame as the source animation\n",
    "    target.frames = source.frames\n",
    "    target.frametime = source.frametime\n",
    "    #print('Done!')\n",
    "#Perform the initial retargeting\n",
    "AlignBones(targetAnimation, sourceAnimation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot Target Animation (this may take a few minutes)\n",
    "#_ = PlotBVH(targetAnimation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Surface Characterization\n",
    "\n",
    "## Surface Calibration\n",
    "\n",
    "Molla defined a set of points to characterize the surface of the 3D model’s and performer’s body, the yellow dots on Figure 5.1.  The points are connected throughtriangles to create a mesh that represents the body surface. The points on the surfaceof the character and the performer need to be collected as close to the relative positionas possible, since the triangle mesh differences between the characters must represent differences of the characters’ surface, thus sampling surface points from different placesintroduces noise to the analysis. The thickness of the limbs are also registered and later they are represented by capsules to avoid self-penetration in the animation.\n",
    "\n",
    "![Character Surface Calibration](../figures/TalitaPoints.png)\n",
    "\n",
    "The user obtains the surface points and radius of each limb of the character during its creation or through a 3D modeling software.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Surface Motion Estimation\n",
    "\n",
    "Collecting the position of the surface points is not enough because the performer may walk around, jump or simply twist his torso. In those cases, the sampled points do not represent the current surface position, since we do not keep track of these points. To include the surface deformation - translation and twist effects - we attach each calibration point representing the character mesh (yellow dots in Figure) to the nearest mapped joint. Thus, the point behaves as a child of the mapped joint and the transformations from every joint in the hierarchy is also applied to the point.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def PlotBVHSurface(animation, surface):\n",
    "    %matplotlib qt\n",
    "    def update(frame, surf, lines, vertices, bones):\n",
    "        for triangle_plot, triangle in zip(surf, range(len(surf))):\n",
    "            triangle_plot.set_data(vertices[frame,triangle,:,0],vertices[frame,triangle,:,1])\n",
    "            triangle_plot.set_3d_properties(vertices[frame,triangle,:,2])\n",
    "        \n",
    "        for line, bone in zip(lines, range(len(lines))):\n",
    "            line.set_data([bones[frame,bone,0], bones[frame,bone,3]], [bones[frame,bone,1], bones[frame,bone,4]])\n",
    "            line.set_3d_properties([bones[frame,bone,2], bones[frame,bone,5]])\n",
    "        return surf+lines\n",
    "\n",
    "    fig = plt.figure(figsize=(12,8))\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "\n",
    "    print('Preparing plot:')\n",
    "    print('Computing Surface...')\n",
    "    #Draw Surface Mesh ###############################################\n",
    "    vertices = [] #vertices[frame, triangle, edge, xyz]\n",
    "    for frame in range(animation.frames):\n",
    "        vertices_oneframe = []\n",
    "        for triangle in surface.headmesh + surface.bodymesh:\n",
    "            edge_0 = triangle[0].getPosition(animation,frame)\n",
    "            edge_1 = triangle[1].getPosition(animation,frame)\n",
    "            edge_2 = triangle[2].getPosition(animation,frame)\n",
    "            vertices_oneframe.append([edge_0, edge_1, edge_2, edge_0])\n",
    "        vertices.append(vertices_oneframe)\n",
    "    vertices = np.asarray(vertices)\n",
    "    mindata = vertices.min()\n",
    "    maxdata = vertices.max()\n",
    "    \n",
    "    surf = []\n",
    "    for triangle in range(vertices.shape[1]):\n",
    "        surf.append(ax.plot(vertices[0,triangle,:,0],vertices[0,triangle,:,1],vertices[0,triangle,:,2],'-o', color='red', markersize=1, alpha = 0.5)[0])\n",
    "\n",
    "    print('Computing Bones...')\n",
    "    #Draw Bones #######################################################\n",
    "    bones = []\n",
    "    for frame in range(animation.frames):\n",
    "        bones.append(animation.getBones(frame))\n",
    "    bones = np.asarray(bones)\n",
    "    \n",
    "    lines = []\n",
    "    for bone in animation.getBones(0):\n",
    "        lines.append(ax.plot([bone[0], bone[3]], [bone[1], bone[4]], [bone[2], bone[5]],'-o', color='black')[0])\n",
    "        \n",
    "    ax.set_xlabel('X Label')\n",
    "    ax.set_ylabel('Y Label')\n",
    "    ax.set_zlabel('Z Label')\n",
    "    ax.set_xlim(mindata,maxdata)\n",
    "    ax.set_ylim(mindata,maxdata)\n",
    "    ax.set_zlim(mindata,maxdata)\n",
    "    ani = FuncAnimation(fig, update, frames=np.arange(animation.frames), fargs=(surf,lines,vertices,bones) ,interval=0.5, blit=True)\n",
    "    return ani\n",
    "\n",
    "#"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Plot Source Animation with Surface\n",
    "#_ = PlotBVHSurface(sourceAnimation,sourceSurface)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x576 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def PlotBVHSurfaceFrames(srcAnim, srcSurface, tgtAnim, tgtSurface, f1, f2, f3):\n",
    "    %matplotlib inline\n",
    "    fig, axs = plt.subplots(2, 3, figsize=(16,8))\n",
    "    \n",
    "    min_X, max_X = np.inf,np.NINF\n",
    "    min_Y, max_Y = np.inf,np.NINF\n",
    "    for animation, surface, line in zip([srcAnim, tgtAnim],[srcSurface, tgtSurface],range(2)):\n",
    "        for frame, column in zip([f1,f2,f3],range(3)):\n",
    "            aux = animation.getBones(frame)\n",
    "            bones = []\n",
    "            for i in range(len(aux)):\n",
    "                axs[line, column].plot([aux[i,0], aux[i,3]], [aux[i,1], aux[i,4]],'-o', color='black')\n",
    "            surf = []\n",
    "            for triangle in surface.headmesh:\n",
    "                vertices = [[vert.getPosition(animation,frame)[0],vert.getPosition(animation,frame)[1]] for vert in triangle]\n",
    "                vertices.append([triangle[0].getPosition(animation,frame)[0],triangle[0].getPosition(animation,frame)[1]])\n",
    "                vertices = np.asarray(vertices)\n",
    "                axs[line, column].plot(vertices[:,0],vertices[:,1],'-o', color='red', markersize=1, alpha = 0.5)\n",
    "\n",
    "            for triangle in surface.bodymesh:\n",
    "                vertices = [[vert.getPosition(animation,frame)[0],vert.getPosition(animation,frame)[1]] for vert in triangle]\n",
    "                vertices.append([triangle[0].getPosition(animation,frame)[0],triangle[0].getPosition(animation,frame)[1]])\n",
    "                vertices = np.asarray(vertices)\n",
    "                axs[line, column].plot(vertices[:,0],vertices[:,1],'-o', color='red', markersize=1, alpha = 0.5)\n",
    "            mini_X,maxi_X = np.min([aux[:,0].min(),aux[:,3].min()]), np.max([aux[:,0].max(),aux[:,3].max()])\n",
    "            mini_Y, maxi_Y = np.min([aux[:,1].min(),aux[:,4].min()]), np.max([aux[:,1].max(),aux[:,4].max()])\n",
    "            if mini_X<min_X: \n",
    "                min_X=mini_X\n",
    "            if maxi_X>max_X: \n",
    "                max_X=maxi_X\n",
    "            if mini_Y<min_Y: \n",
    "                min_Y=mini_Y\n",
    "            if maxi_Y>max_Y: \n",
    "                max_Y=maxi_Y\n",
    "    for line in range(2):\n",
    "        for column in range(3):\n",
    "            axs[line, column].set_xlim(min_X-5,max_X+5)\n",
    "            axs[line, column].set_ylim(min_Y-10,max_Y+10)\n",
    "            axs[line, column].set_frame_on(False)\n",
    "            axs[line, column].tick_params(axis='both', which='both', length=0)\n",
    "            axs[line, column].set_xticks([])\n",
    "            if column!=0:\n",
    "                axs[line, column].set_yticks([])\n",
    "            #axs[line, column].set_axis_off()\n",
    "    frames = [f1,f2,f3]\n",
    "    font_size = 16\n",
    "    for column in range(3):\n",
    "        axs[1,column].set_xlabel(str.format('Frame %i' % frames[column]), fontsize=font_size)\n",
    "        \n",
    "    axs[0,0].set_ylabel('Source', fontsize=font_size)\n",
    "    axs[1,0].set_ylabel('Target', fontsize=font_size)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "PlotBVHSurfaceFrames(sourceAnimation, sourceSurface, targetAnimation, targetSurface, 0, 100,200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computing Egocentric Coordinates\n",
    "We compute the egocentric coordinates of each limb joint in respect to each triangle in the surface mesh and for each capsule limb. Molla computes the projection of the joint's position $\\mathbf{p}$ on the $m$ triangles of the mesh, the projected point $\\mathbf{x}$ is called the reference point, and the displacement vector $\\mathbf{v}$ is the distance of the joint's position to the reference point. Then, the position of joint $n$ regarding the surface component $i$ is expressed as the equation: \n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:egocoord_jointpos1}\n",
    "\\mathbf{p}_n = \\mathbf{x}_i + \\mathbf{v}_i\n",
    "\\end{equation}\n",
    "        \n",
    "The position is expressed likewise for the limbs, but the reference point is the intersection between the capsule surface and the line that passes through the center of the capsule and the joint's position. Then, combining all the surface components, limbs and meshes, the previous equation becomes:\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:egocoord_jointpos2}\n",
    "\\mathbf{p}_n = \\sum_{i=1}^{m}\\hat{\\lambda}_{i}(\\mathbf{x}_i + \\mathbf{v}_i)\n",
    "\\end{equation}\n",
    "\n",
    "The importance factor $\\lambda$ of a surface component is metric that encodes the proximity and orthogonality between the component and the joint's position. The goal of the importance factor is allow that surface components that are near and more perpendicular to the joint have a higher contribution on the joint's position calculation.\n",
    "\n",
    "Furthermore, a small distance between the joint and the surface may indicate that a interaction is occurring, covering the eyes with the hand as an example. In this case, we desire that the weights of the hand position that a surface component in head express excel the weights of the torso surface component, in order to preserve the interaction between the head and not the torso. \n",
    "\n",
    "The importance factor of a surface component is the combination of the proximity $\\lambda_p$ and the orthogonality $\\lambda_{\\perp}$ properties:\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:importance}\n",
    "\\lambda = \\lambda_p \\lambda_{\\perp}\\hspace{0.1cm},\\hspace{0.2cm} with \\hspace{0.5cm}\\lambda_p =  \\frac{1}{||\\mathbf{v}||}\\hspace{0.5cm} and \\hspace{0.5cm}\\lambda_{\\perp} = cos(\\alpha)\n",
    "\\end{equation}\n",
    "\n",
    "    \n",
    "where $\\alpha$ is the angle between the displacement vector $\\mathbf{v}$ and the surface component normal. Finally, $\\hat{\\lambda}_{i}$ is computed as\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:importance_ortho}\n",
    "\\hat{\\lambda}_{i} = \\frac{\\lambda_{i}}{\\sum_{j=1}^{m}\\lambda_{j}}\n",
    "\\end{equation}\n",
    "    \n",
    "Using the target character surface information to compute the reference points and the displacement vectors from the source skeleton, and reversing Equation, we obtain the position for a target skeleton joint with the same distance from its surface as the source skeleton distance from its respective surface. But differences in the body proportions and bones length between the skeletons still were not taken into account, which will result in odd-looking poses or in a position impossible to reach.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def importanceCalc(dispvector, normal):\n",
    "        \"\"\"\n",
    "        Compute the importance factor for a given mesh component\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        dispvector : numpy array\n",
    "                    Displacement vector. The vector from the component's reference point to the joint.\n",
    "                    \n",
    "        normal : numpy array\n",
    "                Component's normal.\n",
    "        \"\"\"\n",
    "        epsilon = 0.01\n",
    "        normdispvector = np.linalg.norm(dispvector)\n",
    "        if normdispvector <= epsilon:\n",
    "            proximity = 1/epsilon\n",
    "        else:\n",
    "            proximity = 1/normdispvector\n",
    "        normal_unit = normal/np.linalg.norm(normal)\n",
    "        dispvector_unit = dispvector/normdispvector\n",
    "        orthogonality = np.clip(np.dot(normal_unit, dispvector_unit), -1.0, 1.0)\n",
    "        if orthogonality < epsilon:\n",
    "            orthogonality = epsilon\n",
    "        orthogonality = np.abs(orthogonality)\n",
    "        return orthogonality*proximity, orthogonality, proximity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kinematic Path Normalization\n",
    "Molla proposes the Kinematic Path Normalization to adjust the joints' position according to the length of the bones in the skeleton. The kinematic path is the route through joints and bone segments from a reference point to a limb joint. Figure BLA represents three different kinematics path for the limb joint right hand: first and second, the path from the reference point of a torso and a head mesh component; and third, the path from the reference point of a limb capsule.\n",
    "\n",
    "Note that the goal of the Kinematic Path Normalization is to adjust the position of the joint accordingly to the length of the bone segments. Thus, since the source and target skeleton may have different topologies, the joints and bone segments of the kinematic path are (the mapped joints).\n",
    "\n",
    "Given the path along the skeleton from the joint being evaluated until the nearest joint of the surface component or until the extremity joint for limbs capsules, we compute the displacement vector as\n",
    "\n",
    "\\begin{equation}\n",
    "\\label{eq:dispvector}\n",
    "\\mathbf{v} = \\mathbf{-x}_{j0} + \\sum_{i=1}^{n} \\mathbf{s}_i\n",
    "\\end{equation}\n",
    "\n",
    "<img src=\"../figures/SkeletonKinematicPath.svg\" alt=\"drawing\" width=\"300\"/>\n",
    "\n",
    "(em construção)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pathnormCalc(joint, animation, mesh, frame, refpoint, vectors, surface = None):\n",
    "    \"\"\"\n",
    "    Calcula a normalização do caminho cinemático. Recebe a junta e sobe na\n",
    "    hierarquia. Caminho cinemático utilizado: Mão - Cotovelo - Ombro -\n",
    "    Espinha - Cabeça ou Quadris.\n",
    "    Retorna o vetor de deslocamento normalizado e o vetor de cossenos\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    joint : \n",
    "    animation : \n",
    "    mesh : \n",
    "    frame : \n",
    "    refpoint : \n",
    "    vectors : \n",
    "    surface : \n",
    "    \"\"\"\n",
    "    #TODO: Fazer o Ground\n",
    "    #Get bone vectors\n",
    "    lvec_fore, rvec_fore, lvec_arm, rvec_arm, lvec_clavicle, rvec_clavicle, vec_neck, vec_spine, lvec_femur, rvec_femur, lvec_upleg, rvec_upleg, lvec_lowleg, rvec_lowleg = vectors\n",
    "    #Get mapped joints\n",
    "    lhand, rhand, lforearm, rforearm = animation.getskeletonmap().lhand, animation.getskeletonmap().rhand, animation.getskeletonmap().lforearm, animation.getskeletonmap().rforearm\n",
    "    lfoot, rfoot, llowleg, rlowleg = animation.getskeletonmap().lfoot, animation.getskeletonmap().rfoot, animation.getskeletonmap().llowleg, animation.getskeletonmap().rlowleg\n",
    "    #Defines the kinematic path for each joint\n",
    "    if joint == lhand:\n",
    "        kinpath = np.asarray([lvec_clavicle, lvec_arm, lvec_fore])\n",
    "    elif joint == rhand:\n",
    "        kinpath = np.asarray([rvec_clavicle, rvec_arm, rvec_fore])\n",
    "    elif joint == lforearm:\n",
    "        kinpath = np.asarray([lvec_clavicle, lvec_arm])\n",
    "    elif joint == rforearm:\n",
    "        kinpath = np.asarray([rvec_clavicle, rvec_arm])\n",
    "    elif joint == lfoot:\n",
    "        kinpath = np.asarray([lvec_femur, lvec_upleg, lvec_lowleg])\n",
    "    elif joint == rfoot:\n",
    "        kinpath = np.asarray([rvec_femur, rvec_upleg, rvec_lowleg])\n",
    "    elif joint == llowleg:\n",
    "        kinpath = np.asarray([lvec_femur, lvec_upleg])\n",
    "    elif joint == rlowleg:\n",
    "        kinpath = np.asarray([rvec_femur, rvec_upleg])\n",
    "\n",
    "    #Get vector displacement\n",
    "    if joint == lhand or joint == rhand or joint == lforearm or joint == rforearm:\n",
    "        cos = np.empty(len(kinpath)+1)\n",
    "        #Upper limb\n",
    "        if mesh == 'head':\n",
    "            vec_displacement = -(refpoint - animation.getskeletonmap().head.getPosition(frame)) + vec_neck\n",
    "            vec_displacement = vec_displacement + kinpath.sum(axis = 0)\n",
    "            cos[0] = mathutils.cosBetween(vec_displacement, vec_neck)\n",
    "            tau = np.linalg.norm(vec_neck)*cos[0]\n",
    "        elif mesh == 'body':\n",
    "            vec_displacement = -(refpoint - animation.getskeletonmap().hips.getPosition(frame)) + vec_spine\n",
    "            vec_displacement = vec_displacement + kinpath.sum(axis = 0)\n",
    "            cos[0] = mathutils.cosBetween(vec_displacement, vec_spine)\n",
    "            tau = np.linalg.norm(vec_spine)*cos[0]\n",
    "        else:\n",
    "            raise Exception('Upper limb joints only accept meshes from the head and body.')\n",
    "        #Get tau (Eray Molla Eq 5)\n",
    "        for i in range(1,len(cos)):\n",
    "            cos[i] = mathutils.cosBetween(vec_displacement, kinpath[i-1])\n",
    "            tau = tau + np.linalg.norm(kinpath[i-1])*cos[i]\n",
    "    else:\n",
    "        #Lower limbs\n",
    "        if mesh == 'head':\n",
    "            cos = np.empty(len(kinpath)+2)\n",
    "            vec_displacement = -(refpoint - animation.getskeletonmap().head.getPosition(frame)) + vec_neck - vec_spine\n",
    "            vec_displacement = vec_displacement + kinpath.sum(axis = 0)\n",
    "            cos[0] = mathutils.cosBetween(vec_displacement, vec_neck)\n",
    "            cos[1] = mathutils.cosBetween(vec_displacement, -vec_spine)\n",
    "            tau = np.linalg.norm(vec_neck)*cos[0] + np.linalg.norm(-vec_spine)*cos[1]\n",
    "            for i in range(2,len(cos)):\n",
    "                cos[i] = mathutils.cosBetween(vec_displacement, kinpath[i-2])\n",
    "                tau = tau + np.linalg.norm(kinpath[i-2])*cos[i]\n",
    "        elif mesh == 'body':\n",
    "            cos = np.empty(len(kinpath))\n",
    "            vec_displacement = -(refpoint - animation.getskeletonmap().hips.getPosition(frame))\n",
    "            vec_displacement = vec_displacement + kinpath.sum(axis = 0)\n",
    "            tau = 0\n",
    "            for i in range(len(cos)):\n",
    "                cos[i] = mathutils.cosBetween(vec_displacement, kinpath[i])\n",
    "                tau = tau + np.linalg.norm(kinpath[i])*cos[i]\n",
    "        elif mesh == 'ground':\n",
    "            assert joint == rfoot or joint == lfoot, 'Foot contact should only be randled with the right and left foot'\n",
    "            hipsPosition = animation.getskeletonmap().hips.getPosition(frame)\n",
    "            hipsGround = np.asarray([hipsPosition[0], 0, hipsPosition[2]])\n",
    "            hipsHeight = np.asarray([0, hipsPosition[1], 0])\n",
    "            vec_displacement = -(refpoint - hipsGround) + hipsHeight\n",
    "            vec_displacement = vec_displacement+ kinpath.sum(axis = 0)\n",
    "            cos = np.empty(len(kinpath)+1)\n",
    "            cos[0] = mathutils.cosBetween(vec_displacement, hipsHeight)\n",
    "            tau = 0\n",
    "            for i in range(1,len(cos)):\n",
    "                cos[i] = mathutils.cosBetween(vec_displacement, kinpath[i-1])\n",
    "                tau = tau + np.linalg.norm(kinpath[i-1])*cos[i]\n",
    "    return vec_displacement/tau, cos, tau\n",
    "\n",
    "def GetEgocentricCoordinatesTargets(source, sourceSurface, target, targetSurface):\n",
    "    headmesh = sourceSurface.headmesh\n",
    "    bodymesh = sourceSurface.bodymesh\n",
    "    headmesh_target = targetSurface.headmesh\n",
    "    bodymesh_target = targetSurface.bodymesh\n",
    "    ego = None\n",
    "    #Cleaning instances in case of multiple animation being retargeted\n",
    "    egocentriccoord.EgocentricCoordinate.clean()\n",
    "\n",
    "    #Get source skeleton map\n",
    "    source_skmap = source.getskeletonmap()\n",
    "    lhand, rhand = source_skmap.lhand, source_skmap.rhand\n",
    "    lforearm, rforearm = source_skmap.lforearm, source_skmap.rforearm\n",
    "    larm, rarm = source_skmap.larm, source_skmap.rarm\n",
    "    lupleg, rupleg = source_skmap.lupleg, source_skmap.rupleg\n",
    "    llowleg, rlowleg = source_skmap.llowleg, source_skmap.rlowleg\n",
    "    lfoot, rfoot = source_skmap.lfoot, source_skmap.rfoot\n",
    "\n",
    "    #Get target skeleton map\n",
    "    target_skmap = target.getskeletonmap()\n",
    "    lhand_tgt, rhand_tgt = target_skmap.lhand, target_skmap.rhand\n",
    "    lforearm_tgt, rforearm_tgt = target_skmap.lforearm, target_skmap.rforearm\n",
    "    larm_tgt, rarm_tgt = target_skmap.larm, target_skmap.rarm\n",
    "    lupleg_tgt, rupleg_tgt = target_skmap.lupleg, target_skmap.rupleg\n",
    "    llowleg_tgt, rlowleg_tgt = target_skmap.llowleg, target_skmap.rlowleg\n",
    "    lfoot_tgt, rfoot_tgt = target_skmap.lfoot, target_skmap.rfoot\n",
    "\n",
    "    start=time.time()\n",
    "\n",
    "    ground_normal = np.asarray([0,1,0])\n",
    "\n",
    "    egocentriccoord.EgocentricCoordinate(rhand)\n",
    "    egocentriccoord.EgocentricCoordinate(lhand)\n",
    "    #egocentriccoord.EgocentricCoordinate(rforearm)\n",
    "    #egocentriccoord.EgocentricCoordinate(lforearm)\n",
    "    #egocentriccoord.EgocentricCoordinate(rfoot)\n",
    "    #egocentriccoord.EgocentricCoordinate(lfoot)\n",
    "    #egocentriccoord.EgocentricCoordinate(rlowleg)\n",
    "    #egocentriccoord.EgocentricCoordinate(llowleg)\n",
    "\n",
    "    #Para cada frame\n",
    "    for frame in range(source.frames):\n",
    "        if np.mod(frame+1,100) == 0:\n",
    "            #print('%i frames done. %s seconds.' % (int((frame+1)/100)*100,time.time()-start))\n",
    "            start=time.time()\n",
    "            \n",
    "        vectors = egocentriccoord.getVectors(source, frame)\n",
    "        #For each limb joint or end effector\n",
    "        #for joint in [rhand, lhand, rforearm, lforearm, rfoot, lfoot, rlowleg, llowleg]:\n",
    "        for joint in [rhand, lhand]:\n",
    "            ego = egocentriccoord.EgocentricCoordinate.getCoord(joint.name).addCoordFrame(frame)\n",
    "            jointPosition = joint.getPosition(frame)\n",
    "\n",
    "            #Eray Molla Equation 3\n",
    "            #Get the surface normal of extrimities joints\n",
    "            if joint == rhand or joint == lhand or joint == rfoot or joint == lfoot:\n",
    "                jointSurfaceNormal = egocentriccoord.extremityNormal(source, joint, frame)\n",
    "\n",
    "            #Mesh components\n",
    "            for i in range(len(bodymesh)+len(headmesh)):\n",
    "                if i<len(headmesh):\n",
    "                    refpoint, dispvector, normal = mathutils.distFromCentroid(jointPosition, headmesh[i][0].getPosition(source, frame), headmesh[i][1].getPosition(source, frame), headmesh[i][2].getPosition(source, frame))\n",
    "                    dispvector_norm, normcoef, tau = pathnormCalc(joint, source, 'head', frame, refpoint, vectors)\n",
    "                else:\n",
    "                    j = i-len(headmesh)\n",
    "                    refpoint, dispvector, normal = mathutils.distFromCentroid(jointPosition, bodymesh[j][0].getPosition(source, frame), bodymesh[j][1].getPosition(source, frame), bodymesh[j][2].getPosition(source, frame))\n",
    "                    dispvector_norm, normcoef, tau = pathnormCalc(joint, source, 'body', frame, refpoint, vectors)\n",
    "\n",
    "                importance, ortho, proxi = importanceCalc(dispvector, normal)\n",
    "                #Importance\n",
    "                ego.ortho.append(ortho)\n",
    "                ego.proxi.append(proxi)\n",
    "                ego.importance.append(importance)\n",
    "                #Reference point (triangle mesh)\n",
    "                ego.refpoint.append(refpoint)\n",
    "                #Displacement Vector (distance from refpoint to the joint position)\n",
    "                ego.dispvector.append(dispvector_norm)\n",
    "                #Cosines between each bone and the displacement vector Eray Molla Eq 4\n",
    "                ego.normcoef.append(normcoef)\n",
    "                #Normalization factor Eray Molla Eq 5\n",
    "                ego.tau.append(tau)\n",
    "                ego.normal.append(normal)\n",
    "\n",
    "                #Eray Molla Equation 3\n",
    "                if joint == rhand or joint == lhand or joint == rfoot or joint == lfoot:\n",
    "                    angle,_ = mathutils.angleBetween(normal, jointSurfaceNormal)\n",
    "                    ego.angle.append(angle)\n",
    "\n",
    "            #Limbs components\n",
    "            for values_returned in egocentriccoord.pathnormCalcLimb(joint, source, 'limb', frame, None, vectors, sourceSurface):\n",
    "                dispvector, normcoef, tau, limbname, normal, refpoint, refpoint_aux = values_returned\n",
    "                importance, ortho, proxi = egocentriccoord.importanceCalcLimb(vectors, limbname, dispvector, normal)\n",
    "                ego.ortho.append(ortho)\n",
    "                ego.proxi.append(proxi)\n",
    "                ego.importance.append(importance)\n",
    "                ego.refpoint.append(refpoint)\n",
    "                ego.dispvector.append(dispvector/tau)\n",
    "                ego.normcoef.append(normcoef)\n",
    "                ego.tau.append(tau)\n",
    "                ego.normal.append(normal)\n",
    "                #Eray Molla Equation 3\n",
    "                if joint == rhand or joint == lhand or joint == rfoot or joint == lfoot:\n",
    "                    angle,_ = mathutils.angleBetween(normal, jointSurfaceNormal)\n",
    "                    ego.angle.append(angle)\n",
    "\n",
    "            #Add the ground projection as a reference point\n",
    "            if joint == rfoot or joint == lfoot:\n",
    "                refpoint = np.asarray([jointPosition[0], 0,jointPosition[2]])\n",
    "                dispvector_norm, normcoef, tau = pathnormCalc(joint, source, 'ground', frame, refpoint, vectors)\n",
    "                importance, ortho, proxi = importanceCalc(dispvector, ground_normal)\n",
    "                ego.ortho.append(ortho)\n",
    "                ego.proxi.append(proxi)\n",
    "                ego.importance.append(importance)\n",
    "                ego.refpoint.append(refpoint)\n",
    "                ego.dispvector.append(dispvector_norm)\n",
    "                ego.normcoef.append(normcoef)\n",
    "                ego.tau.append(tau)\n",
    "                ego.normal.append(normal)\n",
    "                angle,_ = mathutils.angleBetween(ground_normal, jointSurfaceNormal)\n",
    "                ego.angle.append(angle)\n",
    "                \n",
    "            #Normaliza a importancia\n",
    "            sumimp = sum(ego.importance)\n",
    "            ego.importance = np.asarray([ego.importance[element]/sumimp for element in range(len(ego.importance))])\n",
    "\n",
    "\n",
    "        #####################################################################################\n",
    "        # Computing Targets for each end effector in each frame\n",
    "        #####################################################################################\n",
    "        vectors = egocentriccoord.getVectors(target, frame)\n",
    "        lvec_fore, rvec_fore, lvec_arm, rvec_arm, lvec_clavicle, rvec_clavicle, vec_neck, vec_spine, lvec_femur, rvec_femur, lvec_upleg, rvec_upleg, lvec_lowleg, rvec_lowleg = vectors\n",
    "        #For each limb joint or end effector\n",
    "        #for joint,egoindex in zip([rhand_tgt, lhand_tgt, rforearm_tgt, lforearm_tgt, rfoot_tgt, lfoot_tgt, rlowleg_tgt, llowleg_tgt],range(6)):\n",
    "        for joint,egoindex in zip([rhand_tgt, lhand_tgt],range(2)):\n",
    "            #Get the ego coordinates of the mocap animation joint\n",
    "            # aux_jointname = skeletonmap.getmatchingjoint(joint.name, mocap).name\n",
    "            ego = egocentriccoord.EgocentricCoordinate.egolist[egoindex].getCoordFrame(frame)\n",
    "\n",
    "            #For each mesh triangle\n",
    "            vec_displacement = []\n",
    "            de_refpoint = []\n",
    "            position = []\n",
    "            taulist = []\n",
    "            normallist = []\n",
    "            for i in range(len(bodymesh_target)+len(headmesh_target)):\n",
    "                if i<len(headmesh_target):\n",
    "                    de_refpoint_aux, normal = mathutils.getCentroid(headmesh_target[i][0].getPosition(target, frame),headmesh_target[i][1].getPosition(target, frame), headmesh_target[i][2].getPosition(target, frame))\n",
    "                    if joint == lhand_tgt: kinpath = np.asarray([vec_neck, lvec_clavicle, lvec_arm, lvec_fore])\n",
    "                    elif joint == rhand_tgt: kinpath = np.asarray([vec_neck, rvec_clavicle, rvec_arm, rvec_fore])\n",
    "                    elif joint == lforearm_tgt: kinpath = np.asarray([vec_neck, lvec_clavicle, lvec_arm])\n",
    "                    elif joint == rforearm_tgt: kinpath = np.asarray([vec_neck, rvec_clavicle, rvec_arm])\n",
    "                    elif joint == lfoot_tgt: kinpath = np.asarray([vec_neck, vec_spine, lvec_femur, lvec_upleg, lvec_lowleg])\n",
    "                    elif joint == rfoot_tgt: kinpath = np.asarray([vec_neck, vec_spine, rvec_femur, rvec_upleg, rvec_lowleg])\n",
    "                    elif joint == llowleg_tgt: kinpath = np.asarray([vec_neck, vec_spine, lvec_femur, lvec_upleg])\n",
    "                    elif joint == rlowleg_tgt: kinpath = np.asarray([vec_neck, vec_spine, rvec_femur, rvec_upleg])\n",
    "                else:\n",
    "                    j = i-len(headmesh_target)\n",
    "                    de_refpoint_aux, normal = mathutils.getCentroid(bodymesh_target[j][0].getPosition(target, frame),bodymesh_target[j][1].getPosition(target, frame), bodymesh_target[j][2].getPosition(target, frame))\n",
    "                    if joint == lhand_tgt: kinpath = np.asarray([vec_spine, lvec_clavicle, lvec_arm, lvec_fore])\n",
    "                    elif joint == rhand_tgt: kinpath = np.asarray([vec_spine, rvec_clavicle, rvec_arm, rvec_fore])\n",
    "                    elif joint == lforearm_tgt: kinpath = np.asarray([vec_spine, lvec_clavicle, lvec_arm])\n",
    "                    elif joint == rforearm_tgt: kinpath = np.asarray([vec_spine, rvec_clavicle, rvec_arm])\n",
    "                    elif joint == lfoot_tgt: kinpath = np.asarray([lvec_femur, lvec_upleg, lvec_lowleg])\n",
    "                    elif joint == rfoot_tgt: kinpath = np.asarray([rvec_femur, rvec_upleg, rvec_lowleg])\n",
    "                    elif joint == llowleg_tgt: kinpath = np.asarray([lvec_femur, lvec_upleg])\n",
    "                    elif joint == rlowleg_tgt: kinpath = np.asarray([rvec_femur, rvec_upleg])\n",
    "                tau = (np.linalg.norm(kinpath, axis = 1)*ego.normcoef[i]).sum()\n",
    "                vec_displacement_aux = ego.dispvector[i]*tau\n",
    "                taulist.append(tau)\n",
    "                vec_displacement.append(vec_displacement_aux)\n",
    "                de_refpoint.append(de_refpoint_aux)\n",
    "                position.append(vec_displacement_aux+de_refpoint_aux)\n",
    "                normallist.append(normal)\n",
    "\n",
    "            #Get limb coordinates\n",
    "            for values_returned in egocentriccoord.DenormEgoLimb(joint, target, targetSurface, frame, vectors, ego, i+1):\n",
    "                vec_displacement_aux, de_refpoint_aux, tau, normal = values_returned\n",
    "                taulist.append(tau)\n",
    "                vec_displacement.append(vec_displacement_aux)\n",
    "                de_refpoint.append(de_refpoint_aux)\n",
    "                position.append(vec_displacement_aux+de_refpoint_aux)\n",
    "                normallist.append(normal)\n",
    "\n",
    "            if joint == rfoot_tgt or joint == lfoot_tgt:\n",
    "                jointPosition = joint.getPosition(frame)\n",
    "                hipsPosition = target.getskeletonmap().hips.getPosition(frame)\n",
    "                hipsGround = np.asarray([hipsPosition[0], 0, hipsPosition[2]])\n",
    "                hipsHeight = np.asarray([0, hipsPosition[1], 0])\n",
    "                de_refpoint_aux = np.asarray([jointPosition[0], 0, jointPosition[2]])\n",
    "                if joint == rfoot:\n",
    "                    kinpath = np.asarray([-de_refpoint_aux, -hipsGround, hipsHeight, rvec_femur, rvec_upleg, rvec_lowleg])\n",
    "                else:\n",
    "                    kinpath = np.asarray([-de_refpoint_aux, -hipsGround, hipsHeight, lvec_femur, lvec_upleg, lvec_lowleg])\n",
    "                vec_displacement_aux = kinpath.sum(axis = 0)\n",
    "                cos = np.empty(len(kinpath))\n",
    "                tau = 0\n",
    "                for i in range(len(cos)):\n",
    "                    cos[i] = mathutils.cosBetween(vec_displacement_aux, kinpath[i])\n",
    "                    tau = tau + np.linalg.norm(kinpath[i])*cos[i]\n",
    "                vec_displacement_aux = ego.dispvector[-1]*tau\n",
    "                taulist.append(tau)\n",
    "                vec_displacement.append(vec_displacement_aux)\n",
    "                de_refpoint.append(de_refpoint_aux)\n",
    "                position.append(vec_displacement_aux+de_refpoint_aux)\n",
    "                normallist.append([0,1,0])\n",
    "                \n",
    "            ego.tgt_dispvector = np.asarray(vec_displacement)\n",
    "            ego.tgt_tau = np.asarray(taulist)\n",
    "            ego.tgt_refpoint = np.asarray(de_refpoint)\n",
    "            ego.targets = np.asarray(position)\n",
    "            ego.tgt_normal = np.asarray(normallist)\n",
    "\n",
    "    #print('Done!')\n",
    "    return egocentriccoord.EgocentricCoordinate.egolist\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This will take a few minutes\n",
    "egoCoords = GetEgocentricCoordinatesTargets(sourceAnimation, sourceSurface, targetAnimation, targetSurface)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABHgAAAI4CAYAAAARel4VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XecVNX9//HXuVO3zXa2F3oduggiSC82FAvYjVFji8YWvzFGk2h+iV1jiFhjSewFwd4FsVGWXpayLCywLCzbd3Z2Zu7n98eZgQXBxERpnufjMY/ZnZ1y70Xv3Pu+n/M5SkQwDMMwDMMwDMMwDMMwDl/WwV4AwzAMwzAMwzAMwzAM439jAh7DMAzDMAzDMAzDMIzDnAl4DMMwDMMwDMMwDMMwDnMm4DEMwzAMwzAMwzAMwzjMmYDHMAzDMAzDMAzDMAzjMGcCHsMwDMMwDMMwDMMwjMOcCXgMwzAMwzAMwzAMwzAOcwc04FFKPamUqlJKLWvz2ItKqUXR2wal1KLo48VKqUCbv00/kMtqGIZhGIZhGIZhGIZxuHAe4M97Cvgb8EzsARGZEvtZKXUvUNfm+etEpO8BWzrDMAzDMAzDMAzDMIzD0AGt4BGR2cDOff1NKaWAM4HnD+QyGcaPRimFUkkoZYZCGoZhGIZhGIZhGD+qA13B812GAdtEZE2bx9orpUqAeuAWEZlzcBbNMP4DOqR0AXlAAXAxcCrgQalPgHVAA7AZsPe6yff83UYHtLcBPYCxiHx2IFbTMAzjiKGUQkSi+28vkAi8CvQBrgP+0+MO+R6fmgncBWQBFyIy93u81jAMwzAMY7+UyPc5JvkBPlCpYuBNEem11+MPA2tF5N7o7x4gUUSqlVIDgBlATxGpP6ALbBj/CaWuBn4JlKFDHAvoCxRGfw4CpdFnh4FmoCl6qwCqxeVSMvm0bI4/oYP0619sHXfsC6qmJsyeJw4KfVKQDWQAQwEHsBaRzj/yWhqGYRw59LHFHUBXYBXQig7pJ6D3263AciDQ5tbC7tCd6L0AyKRJ6bz//k4VCET29Xf0vjoN6IcOeRzACkR6/ngraRiG8ROjlAtIAZKj932Ao4DfIlJ9MBfNMA6EQ6KCRynlBCYDA2KPiUgQfVKMiCxQSq0DugDzD8pCGsZ3Ow/ogD74X44OXgTYBsQDL6LDnFygHZAmSuXSq5dHxo47TkaNdnPM0Dh8PgcAFRU78PtTmD07NqTRiz4J6Qj4gAiwFV3d5gNeOTCraRiGccTwoysg89Gh+4fAaKARiAMWo0P1NHQYExNC9wvcCVQBVdK/fxwvvXwG77+3kJNO+jj6utgtF+gefZ9YpZCF/r649EdeR8MwjCPH7mrLWHiz930K+ri7rZOAnuiLsHcesGU1jIPkkAh4gDHAKhGpiD2glMoEdopIRCnVAegMrD9YC2gY+6VUNjAbXYmzAj3cMITuJzUUuAKRFQCRCPnoE4jRiIxGqVwAqqvr+OzTjerdd1rUW281qIpNYXSg0woMjL53BP3l9CUwFxiOHgrmAwYdoLU1DMM4/CnlANKBB4Gx6AqerujgvBqYjcit0ecqdAjUC+iGDtqLgCT0kK5i7rijA6C4777X0fvn1cBI4MToa7cDb6KDnQL0CUc55qKVYRjGbnp/m8C+w5vYvWevV8VC91r0Pry2ze9F6GPkeqAVpSxE7B9/RQzj4DmgAY9S6nlgBJChlKoAbhORJ4CpfLu58nDgj0qpMPrE9jIR2WeDZsM4mBbFDZnwke+Ugmczrm16fU0vZ/vW0lxgKVAtWVlO+533hxLhKnSw0yX6su0o9THwEfCRo136ek45GU6dFIe+qnwUcBpwDPoEohU4GZHF7G5I7kBfcT5Z4uJcSikXIqEDue6GYRiHqS5Akrz9TgXt21+qunf7O7rK5hn0yUBw1zP1WPZN0ds7ux5XKgfwy9SzRjNu/EiefWaN+uSTCeh9d3v0cK/PgX8Ar6HDns7AI8AIad/BocrWjwTe/bFX1jAM45CgVCI6wPGy/xBn7/PTFnRYUwtsYHd4E7tvZl89R/QkJ5PQrRM+jr53f0ywbhzhDmjAIyJn7efxC/fx2KvoRoeGcUjx+3GjK3PGWxKeYHf8og+A225pqEjuub7otDHzZfLkFPLzb6VT52Qsayi65H82+sB+PlDucFC+j7dvQV/dHR/9/Wn01eVq9MkC4nQOk2OHDZWbflOD19ONlFQfnToOtTq2H650YGQYhmF8t4GSlRVg/Pj7+Oab1eghtK+jh9YWoC8sfTeRrSJUAjcC1bzxxlTgGnQlkANdXelF5GmUGh59/B1gvfj9Qb762i/Tp9+oTMBjGMZPx+PoEH0mOpwBfYxcB1Siqx/bhjd1iLT8l5/VC12pWYkecpsHjEapFYg0/9drYBiHuENliJZhHLL8fhT6qus4dPAyEn31IZxs16wc1W75/FFTMqqG9A8eY/V50S8uVx9EQixbVqPuvrNG8vLv5OxzNmJZxwIXAfeir+heBBCJkAgczSsvFzrgWHT5/ybgD4gssG/8dT47drwsk055hYZmoTFQgNOp+0EEg0EWzA+pp57agss9FhPwGIZhfDel0oCOPPGEB6WSuP12J/AZ8Ht09eQFQD+USkakDkCETsBVwB1KsSP62FB0uDOGZ56ZoWbMuAs9VOBhoAQ9OYQzGu6MlOnT47n4ksGceUYpt96WQ2urzUN/dXL9dab60jCMn4o8oBh9TP0SurXBbEQqv8+b2DYuy2L/+01dvTMMqIk+0gC8DVyGrqif9X0X3DAOFwd8Fi3DOBz4/SQDo9CBznj0lxHAuqws5p1yCo1nT4kUJCeER+DxeLBtKFtfQ1b2syQmfg14+PSTKykq7kX79nqssEgTSs0FFqKvSuQCQ23b7mdZllX76ScsGjcm0DL8uBkT3n1/OU7nWPRwrbQ9Fi4YDOBylWBZ06x4T6ZqbZ2CbubsRWTij75xDMMwDmdKjQWGyLaqKQQCxbQvflqJ/BKRCEr5gPeBzeh+Z88hskWEf6CHk7dXikqHw3H2V199/WTfPn08rRUVUtOj+6r8YHAWcB8i26KfUww8BqRLz54vs2TptSi1gUhkBg7Hn7j88lL1yPSt6DD/kwO/IQzDMA4wpW4ATkFX1MwHcgA3sA74Ali/z+FWUbZND+AGdHjTY58hj25lMAA4F12deako1cLd99zOiBGjGDJ4lQqFHqdN71fDOJKYCh7DAPx+HOgvg1igMxhdYt+QkMBXxx3H5+edR0r37gxCH+RDc3ATn3+xnNmzPcphSetl16wOWYmnx8PVABw9uJUli3fSUD+XDRuy6NIFunbrjFLjABAJ1JaW7mxZvkx5UlKguD1Dm1riXC5X26GMYWAtodA8rr+u0HrphTy1Y8efEXkUgNbWq9D9eXYCHVGqEyJrf/wtZhiGcRjSs3b2k4kTk8nM7MGDDy5SIjfV1YqdrJ8Rjx4q+xH6pONn8vs/fMNtt50HPKQUlUqpsy8+dfKTAwcO9ADM+7+b1M3BYPvPYLHEwh1tM3pWxZOZ/sj5KJUC/D8cjhf54IMqHn3kPfTMLlMAE/AYhvFTEAEeALLRPXemoS9mHo2ekXYbSn0BLEMkAmDbKHSF+6/RvcwCwJNs2pRAcaEDyAAyo/ex2zDAIwMGdOS009OZMkXRvv0jiAQ54YSHmDHjeJR63DRcNo5EpoLH+Mny+8ln97CrMehKGXE6Wdy7N2VnnIFzzBh6ulx0iL6kEn3Qv5hIRILzFp9tF7bvEZeb6gGorYX586GpiU2TJvEGJSUn0aVzDgmJbgAaG5uori4nL28rra0FQDHx8e7Y8ogI1dXVLFu2lDlz5tT+7ne3HgOsdjiVoEOlzkAnIEfGjLnFfvcDr3rh+V9KYuKxDD02bI0esVktWfIyIvcckA1oGIZxuFHKD5wlTz55FueeV8Qtvx1Qf/OdYeBl4JzkFFUDPIk+6XgHOEs+m305Q4f2JBhsrxLit13jdG7705Kl6XEdO1K+YAHdjxlCq373chEpjn6OAk4G+sl11/XknntP56OPXmX06A5APgUFy3jgAaG8PJ0bb6hSIhNjJzOGYRhHJL1f/B16psFSdKuC+Yi8FQ3fe6EnF2kHNEhi4jdSvikPn+9aLGsQoVANJSUz1ZWXf64WLvSgj9sdbT6hAdgh48blM378RZx0cg6dOsURDsPHH9u8Oaucd9+9W61d+zm6Gf6biJiGy8YRx1TwGD8Zfj9x6NnZYlU6PQCUorKwkIUnnEDr5MkUZWTQF+iLbvD2KfAvINzcjF8pJsTFcQ4OB42d+1FSotjxmW2nplk7uncnNGoUWZZFAXAV2Vn1bNiwg569NgO5JCTkkJjYA+iB0wmhkL155Ure/WIuM2a8xuzZs4mPj2fAgAGkpqYlOxysBJDjjpskvfwT5YKf1dG1q4/a2iHk5X0FIFPPgu3bW/F6PyUhwYtu/mwCHsMwjH07WrxeP5NOyWXnzk/UnXeWUMd09FS6G9BXlQFaEGmU8o2fkp//MB9+uEBNGD8FOOryCy9MT+jWDYDzb7whFu7g9cYVtvmc/kA/GXjUfO6+5xI2btxJaWl/Ro9uD5zKUQNvYvLkwXz00VIl4kZ/N5kqHsMwjmTxgAU0ILIJpb4ChqDUCvT+dz1QLzm5g+T663/OmVP+QEpKApWVjbz80vvq9j/OV9XVQbEsr/z2lkwZMSLdGjvmMWCHzJnjZOixkxC5HKWOBmDlyio2bfojk04OqUWLJqGrKqeg2y6UYRouG0coU8FjHLGizZF7sjvQGQ54gGBqKkuGDaP29NPJ8PvxK4UTPS3uXGAJEGxooKfTybFxcaQAVFXBsmVQVyeRnIT6UJcu4kgrTnFFP64VWIUuG01DjylO3LUwIkJLSz2LF4V5cxbqzVnLGDDwpknV1W/06tUra8CAgfTvP4CioiIAmpqaJCEhYSatrYNwu3ParFYZmzdvVC++UED5hvnqyy++UQsXngScgG7sWQCcikgthmEYxm5KZQJ/l4t+3o3HH+8FnFBfzxfog/4XkpP5OUoNRIfkdyDyoQiPInIBPbq/pVav7i9JSTV1a9b2TkhLs2bNmsVpp00GICkpiXnzVkZyc/OuSfKpGegr02USjozAsn5GWdlVFBZO48MPKpg/fziXXLoCCHDWWSPVJx8/AFQgcv5B2S6GYRgHglI5wC/e6Xz1p0/3f9B+4UX1JbqSpwCYJ/n5G+XW2zpxxpnd8fniKCurVI9MX8D9921T4XCTjBixYe41vxqZ27vPhOLiYmdtba39wQfvP3XmmWcWoSdAsSgrq+Hpp+GNGe+pxYsvRCQY/dx/AW+ij9cno6t9VgFzEZl5ULaHYfxITMBjHFH8ftLR04qPi97yADweyvr0oeKUU4gbOZIecXHEAza6wdsS26aloYGubjeD4+JIAti6FVavhpYWQjk51HXuTFx8PAkA1NbaVGwSklMaSE93EBeXGC09jQmwfl2IdetXs2P7o+qPvx+revfpJiNGhuSkk5tITOxFSsqu5slNTU1YlkVcXBwAIiIqElnHopImNm5cw/gJj5CQsNDhYCcASl0LTALWoodtnYQuN70ceBWRu36sbWwYhnHY0fvnT4AB8uVXjfTvr/hibl59vxG/BO4HBiQnsxClhgG3A7dIc2ATbvc6Xn65Qp01dR2wQp79Zy/OOWdEOBymV6+elJaWAvDnP98fvuKKaxzW+rXHJfbrMhAQ2VpZSlbWW+jAaCKtre0oKlzBy6/kMnhwJ6ZO+Zd69dXzUOp99OxdR5keaoZhHKkW5p7Y/+MOFz84P+/kgSir8oE3Ow3Kblq3RYqLnXL9DRF+dpEiLs5izuyd6p57NvLWm3XExVmcf0GanHNurgwenKosi/ply2hqDZLZqxcuj4fGnTurE7dvf42LLipUX35RhJ7M5Pw9hr0q9Qi6N8/p6DDoBnSftZXAnabhsnEkMQGPcVjz+3GhGyLHeukMBJRlUde+PWvHj0dOPJGOubmkRl+yEh3oNNfW0ik+ngFeL/EAFRWwYQNEIgTz82kqKiLJ6SRWobMZqAcSEclEKe+uhbBtqK5uZdXKeubOXc3XX36hRo/ZTlPz5TJwYBzde6SQm7v7+RBAxIlSLgA7EpGly5apkpKFrFq1cqdS6qG/9OjxN+tnF56N/vJ5FJH6PVZcKQfwKNAbXXn0B+BUdM8HN3CMOVEwDMNoQ6kyyc8vZkM5TH+4nKuvXtJQuvVYIvZ2X9ecMdEhA+OAm4FpMnPW7Ywb14X+/V5SK1bcLrZsw7bLUSq+csaM0oGnTS7aAp7evftumT17QbYFjyelOL4ACuSMM57nxZc+RF8tfhO4DpjIY49O5pJLL+Huuzapm256HT09+2Poys8PEBl3kLaOYRjGj2LqVDzA5ZYdus22XCmuSOAlwbrp2eAZf5aLL53AxIkpiNg4HM/w1ZfT1aiRNfLbW4Zx4kmn073bcDzeeBoamus2lnuTiostR2Ii4S1baHjpRSqff56W+fNb+4s0AS70PvU2RBbYNlnoKdE3WA6VB1wpTuf/STBUqW68IVPdd+81QCF6QpPtwG/NsbNxJDABj3HY8fvpwO5AZxTgAyIZGawbNoymk04it08fshy67VoFsCgcpqmujg6Jifg9HrygA51Nm8DppKWggNbsbHwAIkSUogIQdIf/ZKBtdU4jzc0beOH5VL768mt69/mGHj26kpwygLy89mRnJ+16ZksLOBzgiuZEoVZh3fp6Vq6oU4tK6tTs2e7a+fOSSgKB3D7wbroOkSLofhAJ6Gkj69HVRhL9W+w+Ad0cuh16WFktupqnAHgBkXN+wM1uGIZxeFOqk9x//3tc86sODDrqX619B3lb7pl2mvf6K1Z6nni4CtiB3p8OkQ4dNrFyVTEffrhMnXD8bYDIvPk/p3//EwmFgnTv9tqbZWXjSpSqvK50s5KUtMKEQT3/bpWtKwa+kfnzR9Gv/0Ref+0xTp18MUuXfszvb5vBiy/dzcqVzQzoH1KRSCL6okN99HMnm5MLwzCOFFOnYqF73vwJaO9rqVpw0cIr5w9a9exMtm+/h4KC7gSDAWa8Xqp+f1u5rFx9MXAOeoirHx2QbwTaKYWvpqaGV199hReee47m2bMZY9tMQB/0FkKdxMcnM2Jkk9x882cMHpKPUr2ji/IStbVz+OKLmznmmARSUnzA7yyHuhd4EV3RkwA8b46djSOBCXiMQ57fTyJ65xvrpdMJwOulql8/qk44geThwynw+QA9XfiSYJDGhgYKfT66ud24QYc527aB10tLYSHi8xEX/Yim6Os86EDH3ebjI+jqnW+AD9AzaXUGBiByFEp1avPcVnTjcguAxkZYvAi1ZEmQrVsWqC+/rOGrLxerQCAUfY4FuEph3Hbo2wveSoY16HAnDyhHn3A40AGTI/qa2M8J6KArAT1U63n0ycKJ6KsX5kTBMAwjSgQLkXVUVdWonOyZ9SsqJkpOblFSn/bjrY3lA4F+wKWAS/7+cISf/9zC3+trVVoalJ49vZQsGoTTqbjv3jJ1ww2by+CopKnn4Xn0GY/ntzdscD90rwIaZOLEMLPe7MtLL27hmKGpuFwWffvM54MP/bRvn8Cgo+ar1asHoL8vKtD90/6KSOPB2zqGYRg/nKlTGQXcBQwAFnu9/ObJcc+PZeTIqWRl57B9e5CXX1rIBReeyAP3/4HBg6cyanRytLq9EvAoRaoIzUoxE3g+Ls7712AwWAR653mrZXHKgAHEjxsfbn/mlO107pyDxwOhkLBjRz2pqZV4vZnoCkmor29m3jf1DDnmTuLj37Icaj0wC4gDtgG3mGNn40hgAh7jkOP3Y6FnsYoFOscALsuipWNHKsaOxTV2LAXFxVhKEQCWBgI0NDWR7/PRwe3Ww6oqKqC6GpKSaMnPx+l275o1rhZoQTdBTtzr4+vQIcmc6H0qejaUo9DBTqySJ4T+flEAwcZQeM1aar6c57JLS9lw991caMW5L1ah0BTgN+iy0SJ0GegS4BtEKgFcSl09Dh58Fu6y83pXVBUM7FfRbXTNuH+cff1+N5JSnSQ19QK6dR8nnTplq/fefV1VVa0CHjNT7RqGYXybCGOAD7Dts0JnnR8fePTZJxwl859NHDXogopNci7wTn6BmigFBX9n7bp4PvtsqRo39n2gTtasHUOHDscRDu9g2LFj1DfftAxLTpn1aklph/iG+p0J/bp+KnHxq1SXTq/yxZczUMpFTc1nZGWdw7vvnkP37kdRVPQr3njjD+rUU1KlXbsh+Hwpau3aD4BnEfnq4G4dwzCM/93UqfQG7gQmABt9Pu6YNo1kh4NrgHy2b9+qHrh/o8ye3cKMN5aSnn46kE1LwMayAsrjSRAhHImwoLGRxsZGOorQu7CQBofDcXaHDh0fP3nM6LgrR48hb+QoXKnRDgyBwE527IgnJ0dwOvUF3G3bWqjcupgePZ/E5fpMuZ15KhK5Fbg7OjX7ZOBqYDkiVx6EzWUYPwoT8BiHBL+fbHYPuxoLZAJkZLB12DBax48np39/3G43EWBlYyP1gQC5qakUOJ04bBu2bIH6eiQtjdZ27XBbFkoEUYqd6IqXRNgV8oAOaTaiGy0vQ1fg9AIGAV3YHeaERXDGWig3NdG8fDkNc+fi+fJLUkpKoKwM4mlqdhBZ1IBvlgh/QamzAR8i0wFQKgsYJMrqvT2/b3p5zxPsdX0nh75pqR9pixzdpf2QOnG6kwE965ZSiZddRhA9PrgL0BXoQl1dP8TuSUpqcmxF1IXnP2b989lbY6GRYRiGsScRXkB/z+TW18kdiPwqcXj/B5uPHbes7rd3PQnckl+g7pP33v+U0aMH8MEHfdXECRly1lkn86/nrgXg7bfvVCee8CdEGv7610d2XHDBJenxV1x0n+u5p8eWf1a209GhODM3lx5KcSNwN/AQurpyDnV1b6jUlPnicOQyf8EEOnTIplvXW9TWrQ8hYh+s7WIYhrE/Sqn30PvNmPdFZPzez5s6lULgj8D5QF1aGg/ddRdx8fFcgm518Cn33rOapqa+nHJqd3r39qHbDzQoRbLYNvaWyp2NSblljY10tW0SgSaHg4/T03nX7aYf+vygCCBUW0t9YyNJ7dpF3G63bsrQ3LwJh+MjPJ5P+NtDq61rrj4XPdRrIzp0WgXMQLc/uB54AT11+zRE3v7BN55hHCQm4DEOCr8fD3Asu0OdPgAeD439+1MzYQLpQ4cSn5EBQFldHbWtrWSmppLrdGJFIlBZCYEAkplJODlZV+2IEFKKJvRwq7i9PnYnsCJ6q0IP2z0aHZ5Y0edE0GEQADU1NC1eTMvcuSTMm4d34ULYsgVBD6VaBCwGFh3NVyvnMnSMAzsbeA6RdSF3wonb2h993BtXfzwb6AF0B7oj0h2l2vTpqQ/XbFvhLOrW/+0Ce2NSQaSsU/KwPuUpXdolKUWn6LpEly7SyObNddTVbmLz5m1q3ryQWryomvnzX1ObNr7/v/2rGIZhHJlESAe2ANPr6/kNsBmR95NTreeqXv/8D639BnfB4cjPy8NLOFxOaeknqmePcQBiy4fASGpqtpCT/aQKhSKt5/28qfnB6fe8+95ba6eedUqfbQ88/8vGE6f+JTUVOzWVfwLHoS8aHAt8SSjkolPHJ9WmTTvlX8+N56yzjmf69HfUFZdfjkj5wdouhmEY+7OPcCdmV8gzdSqpwP8B1wBkZPDcbbfhTk/nTPTx9KvAR8BQWlvPwu12EmoN4XK7lILNm2kFdio70i6Cw1LItrh4tSAxkWaXi05K0Tf6mUFaW1uwLB9OpwJYvny5vX79ulUnnXTyH4E5lsWWvVcAPfnIJehzgjfRfTuHAU8BFwPLgYcRWfYDbTbDOOhMwGMcEH4/Cl2BEgt0RgDxShHp1Ikdo0cTN2IEvi5dAKisqaHWtklNS6Odw4EKh6GqCiIR7MxMxOvVIYwILUoRRu+4HW0+shUoQwcxm9DVO0exZ5hjt/mZqioa588n8sUXJC1ciFVSAtu304weUrUYHegsApaK0BR73bRpeIDOnuaaPtnr505p9mUXV+f4nbbD1RHLatvPZ6vbTbnPR01mJqHcXPHkJAfynJ5wV2+yz7XrWbYdBtZhWauBUmA1UKqmnulWr74yVOmTgVnAVegqo23ombbM0CzDMIx9EOEa4AGgT309g9AzVw1v3Fy7QRJ9ZZ45H8zPPHfCtWLLVGz7Kk468Tfq7bfvEmEsEAvPJypLzROHY0BTyZrpAZ+v+PlBPRddmtv+xs0vz33G5bbS8vPZqRQfAOehTyIuQeR8Lrn4MfXkkyvk1de2M+nkf7GwZCVDBt+qwuFXD8oGMQzD+DeUUvs9SZwyReKAK4HfAikZGbx/00048/IYDQSAl9AXVk8FihEJI+JUDovqHbZdU2tZCQkQDkMoxLYsKqu8TTuLrR7dvFiWC32M3og+frewbaG0tJHFizfTqdM9DBgw7/LLfzGtqKi43003/d8nSqkNlsUv97Mi6cCN6Fl3g+iQJ4xucD8PuO9bs9UaxmHMBDzGj8bvJxU9y1Wsl04hQHo6dcOGIaNGkTJwIHi91FVXsxPwpaeTblkQCun+OUphZ2SgHA49XEqEgFI42LMRsqCbEZehw5wwevrwrkQDnOhQLQV6VvMtW2j66ivUV18RX1ICixZBXR1baFOVE72tEyECMG0aiUA3YpU4u6tyOhILl0TEE2qo9dm1jUnp7upsb11yav/i2sw8T4bXSz57zsa1Zfny5TJ37py8jatX41yzxu6zsXzxaWvWvKmCwS3oxs5LEQmh1GD0eOY16C/No9EzaNnovjtb/9d/L8MwjCORCAod1Afq6zkaKEHvi/s2NHAXItemX3Ty1d5t5R0oWXQVq1d/rnr2eFdsuS/63F7AJ8BYpZCGBs4Fnn3w+qvq7MemLbv4mQ89gSGjBubmKbw1W+8jJ+c6dHPRBcCLzJjxsZp86kx5/Ik3Ofvsr2lsVPTr+ze1efM9iDQclI1iGIbxb+w74FEUFZ3N4MH/LAeK0tJYdPXVOLp0wY8+Fv8U3WZhuAhKBNvhwGpoEKmvV8rhgHBYiDQGmtJyPBUJSY5spdAtB4JaS/P5AAAgAElEQVRBG7fbQvdECAPzCIXm8NcHu7N5c2cGD2nk1FPrcLn6ABkAkUiElpaWsoSEhJcti5u+Y2WSgXOBs9E9NX3Aa8A8RO7/YbaYYRwaTMBj/GD8fhzoKplYoHM0YLndtPbvT/Po0SQfcwwqO5uW7dvZ6XCQkJ5OcizQqakBjwc7OXlXKGMDIaVws2cwEkCX2m9Gp/vt0ZU5saqeXWFOJIK9YQMtn3+Oe8ECnCUlsHgxkeZmVrJnkLNYhO0A06aRzu4Qp22QU9hmGcJOJxWJiexISyOYlYU7O5vUtDQKXK42Q6paWlqJREpJSFhCtBIner/G6VR/QV/9wEKPw0oAJsEbj+twJxvdJ6gR3Wj6BeBp9DCyK9BfoJ8h8sl/9y9mGIZx5BNhEPA18Iv6elagm+hf2tDAS+iLAm/lF6hz5csvZ3LUURM5/oTb1PvvOaSufj1JSU+jLyL0V4pFDQ0kA6vWr1+n+vXrnNW//zG8+OLnJCVGyNy8ZBkdOhQRCjVy518u4y93PsvmzXX07HE/RUVPsXTZi0QiIzn99MfVzDeeReSLg7ZRDMMwvoNSKrbf3CUrawx9+txFamo/fD42XXopVv/+5KGPx9cBA2ybBNtGXC5UIADNzRCJgG1jK4nUp7kbE51pybofZjgsseFWQAtLl9awZk0Dkye/AiQSDPYnEhlEfLy+qCsSRqllwEJg4aJFi9YMH37s201NTXeLyG+iQ7Jy0bPtdgQKJSEhny5d2tOhYwYdO3qluNhLamoeBYUOkpODlr/nOYiYSkrjiOL8908xjP3z+ylgd6AzBj3NuHTsSOPIkcjQodClC1Z9PWGnk+bMTBIAb3o6ufX1EAwicXEolwsyM4mgD6QtAKX0NOLoKwKV6FLKTPROuyPQUQRizY9DIezSUkKff4574UIoKYHly2kMBr9VlbPib38jiP4SiIU4k6dN2xXktGuzii0eD1t9PnZmZFCdlUV8u3ZkJSeT4nBQDBSjrzKsQ8+6NQMoZU3pJuusqQNZvOh4JZIQXX4LXQHUDeD3cIUzIQFfYRHJhcUkF+26TQq/9Hylc+brAXSfoN7opnIt0c/aAeSgv1Bn/8//iIZhGEe2i4FmdEj+KHomxefQQXkScLfYkoHISJYt+1y9/55DkpIcxMX9GREhHP6X8rjLgCy1btuf7PSM7Dt+NoXBLjd3/flxJBLEKfWUBcI57ZOSEjjppM+5/fYnCQYTOP74daqpaZ3M+fwGlBrL3/42S818Yxl7nTgZhmEcKpRS5wBPoC+oxqWk9KVPnzvJzh6H01nDOec0hceOTSiwLDYBlZEIeZEIeR6PrpIPBFBNTRAOE/F6aYmPJ0Ef0zt8kKxbIwSDIUpLG6msDOP1BvD76+nWrQt+fw5wM7YdZP36JpYsqcJSszjjzMdRarllEYxOpd65P3T8tcu1rrhDx1/I2ecM4IYbc6WoKJHCQi95+V7y872kp3uwrN0rZ9sRKiuDrFtrUbFpvcTFVahvbQHDOLyZgMf4Xvx+4tHNI2OhTjeAlBRahg3Dceyx0LcvhMPYHg+tGRnEAU6Xi4xAQI+1dTrB5YK0NCLREAeA6NCrWHVOHXrcbQE61MlsG+YEg9grVhCZMwdXSYkOc1avZmMotGdVzjXXsLFzZ4rYXYVzVZuffW0+uzE+nu0pKezIzKSmXTtSMjJol5SEVynaR5+2BV2B8ylteuMAGxwOQntsqG5dYFHJV+LzXWTnFxba/t5O+5hh5XZ+QYpkZaeQ2S7lSm+cinWRjgm3tFC/sRzJnR2PDoXqgPLodl6BrlYahw59ppi+O4ZhGPsnQiJwFvBSfT2JwGnAXxsaCKGbgn6cn89CEe5BKQ9ZWZcCY7n22utwOnMJhyIcM2Q7cG144klZkp5+0ZJ/PELPkgWc/as/ktOhG9nZsPLtxQw4fUx64IM5i+KmnOmif/90rv3VerVieRc544zfkJIymPffL+f661KBL8y+2zCMQ41SygH8CbgJ+Ozoo5/5ldud9nZu7gk5TmeAyZODnHBCKi4XtaEQ6S0tFCQk6GNz24bGRhAhkpCAFZ3J1qEUCdG3b0JfDG1CJBmXqzN+fyp+PzQ3h1m9Kpl169apz+c4WbPmUz76qEiFQojH8xLHjfDyyceXSk5uR7tdu1xeez2V/IJ4cnO9v83M9CinE9EzbIFtC8FgFYoVeLylKFUGbADKmP3ZNjV+3GmqtTUTfXwN+hjbMI4oZoiW8Z2izZH96DBnHDAccDudRPr1IzJ8OO6+fSE5meaEBJzp6bo3TmurviUm6veJ/mdmtw100P1jatGVOW505Ywz9vxYmNPcjL14Mcydi7VwISxaRGjtWpbZ9u4gp3t3Vlx5JZm0na1K/9wV8MY+0OmkLiGB2rQ0wu3aEZeZSUZqKu74+F2f18Ce4U3sfo3Dwbd6JTQ340NX1xTv41YEpO/xApEgIuVEIhuffebJ0RUbN6jN5RvYUr6BLRs3ULNtG5ZIpFyPD3agq37a3rvQV50nAbfsmoLdMAzD+BYRfgY8CRxbX89Y4FagS0MDQ9GzqEzMy2Mh+gTgVaU4T264sZjf/W4dPp/F9OkV6orLnxClaFq05meSlZNxZ/f8eEdmHufOXEhikqJyyRx6jBxBU009KX+69XZ1/303U1pagr/XM3TsOJz5CybS3BygW9dVqq6uD/Brs+82DONQopT6EBgN4Han0rfv/eXt21+Q63BgHX881qRJiNuNHQziTEzUx+mhkL63LMTp3NUrM3Y8HUDPWOtEtxyITYRSAyxEZCEvvxTi8cd8wDLVsWM3PN7RJCd3k6IiJ506B+nQAbKzPW2GccWSpDoCga2Ive75d98t+qpkUa+6ugZaWoJ2fHzSW089Nf3k/azkCcAAdAV8Abrh8p2I2D/09jSMg8kEPMa3+P1kopPwcUoxQYQsgKIiQsOH4+rTB4qKaE1PR6Wl6enJQyG9z/VEu8+IIMQmKNwtgO4no9BDub4V5tTXYy9ciPXFF7BwISxeTM2GDSwU0UFOYSGrr7gCEhPpwp5BTifazKLldlPj89GUkYGVmYkvPZ3E1NRdyxcG1rM7vGkb5FQ6HOz6nyIa4BTv4xYLddL22nwt6BOF2K18r9+r4uOx0Rvnb0R78OxlmohctY/HNT0bwBnAy4hU7/d5hmEYP3EizAXSGxvpbduUAwsbGjgR3XRZgD55efwFuAHooRSrRfgTcDPNzS1c9ov+6tlnVzY0cB7wDHBJSopz+ssvz3X06tWPtLQA9fVhiorSOP74kyPvvjtrLbr6tDf64sWH6N50RylLbcPsuw3DOMQopWYDwxwOL507/xK//3dYViITJigmT9bhTVycfm4koo/bHdEj7jbH8K3owCSR3X0zq9DN5lcB21paCFRWkhcO083lon1CguQk+0hzuVXbi79IZSX2lq0RO0Kl3RQI2O647eGMrK2RlIwm2+l2oRssZ9XX13VMSEiMdzh2T6JbVraOQYM6ffs4Wql2wOXoHpep6N6d6xB59ofajoZxqDABj4HfjxsYAoyzLCbaNn0BlZhI5JhjcPTpA927E+nQAVJSdIgSCoFl7XMHHxNB9zwQIJ59DAesrkYWLkTNnQsLFyJLllBWUcECYFF+PutOOYVA1660U2qPIKeozVvY8fHUpaTQmpGBNyMDX2oqKiVFDwEDtrLvEKcsNqSquZlk9h3cxG6pey12gP2HNxvQAc5//D+VUmox+kQgZomI9PlPX28YhmHsmwjd0UNbb6yvpwJ4Hji+Qddivg1ckJfH2+h99xtKcY4IuegLAB7gaqV4KNpYeTV6nz/knnse+uz88395bLt28NlnX3DCCcfw1FMvkZ2dtHzChIk9gNFK8cmuoAjOVwpzEmEYxiFHKTVKKeujDh0uZODAu4iLS+e002DECCE+Xu0afqWfu6siH6WwYXdVvgiVoRBbGxpoaWrCFQrhi48nPS2NFLcbh4h+rW1DbS3s3KmHdIVCEnZadsTrCKv4JMtOSVGC0xm3z4UNBltVS6CeSHgHlmPzv2a9Mqpy+za1ffs2duyooqpqG1VVlaxduzoiIrvPO/Tl5nPRvTcfQgft7YFPEfn0h9+qhnFwmYDnJ8rvpyMw3rKYAIyxbeIsC3r3Rvr0QfXqhQwciKSm6p13KKR75+y1c28riA51PLSppImprNR9cubMgZISgkuXsqyykvmFhZQdeyxN/frhjoujI7uDnKzYa5UinJREY2oqZGaSkJaGKyUFkpPB4aCRfQ+pKnU4aGhuJoX9hzfF6EqitprZf3izAdj+fQKc7/JfV/AYhmEY/5YI96D77OTV1/MaephAl4YGPkIPg+2Ql8cf0P0meirFShEeA36O/g7oqhStDQ08AFwNHFVVRXUo1LomIcFyrl+/gCFDBlFVVcNVV13E66/PALhbKX4twkR0iPS4UlxywFfeMAxjL0qp99DtFmKPrOzYcXLXESOmWT16ZDFuHHTvri/gxo7193XM39pKSyBASASn243H6cSKhTci0NICgYCu9nE4EI8HZe1Ro7PrvUUpdgDbVPX2VseG9W5xOjeopsadziUlya3HT3rBLmxfpnbu2J50yVSHe/ZHOehj9wLAdRvctg2INdkpR5+M6PeW3UusVBf09OjvIvIVSv08+h7PILL+f9yshnHIMQHPT4Tfjw8YqRTjXS5Oam0lHyA3F+nbF+X3w8iRSHb2runFv6s6xwbCIjj36qmDbcOWLXp41WefwdKlVC9dysKEBNb07Uu934+VmUmmZdENHeQkx17rcBBKTqYlPR1Xejre1FRITYXERCKWtceQql33wSAB9j2EKnbb9f5RsQBnf7cdP1SA8+8opcLsIwwD9rzyYBiGYXwvIriJzjRYX88d6Gl1r2toYA4wD7ghL4+n0Pv9t5RiqsiuZvYKOF0pXm1ooE/0tY9UVXEl8I5th8dnZARpbAyTk+PjpJMm8fTTT1BRsYl+/fp70f3kFgEVwGClCBzYtTcMw9jT3uFO796ncuWV/6Jr1zgGDQKvd3eYEyMi2LZCRE+SEonsbsmwP5EIoXCYHZbFVqeTLUpRBWyDPe5jP1dnZLC74bxSw4FR6KymEN2rZ9Y+VsYJ5I6A9UXgKEAPExD07CQbwH5PXzDeCITQQ7MAHkYkglK/QAf+f0Ek+K33N4zDnAl4jlB+PxbQHxgfF8eklhYGiGB5vdC7N/TpA2PHQufOu7vfx9L1fQ23EkHtHeZEIrBp064wx16+nA3V1awqLGRHt27YubkkeTx0QO9kdzU6drtpTU3FTk/Hk5qKigU58fFsVWr3cCoRSm2breEwCshn3wGOjz018d0BTvWBCnD+HaXUfpdjjysPhmEYxvciwmnAK8Dx9fWchp5JK7+hgenABKAgL49fo4dQ+ZViuQgzgROB+cDRjY0AzEE36+9aVcUJwDPp6bBgQQmjRvXj739/mg4dshg+fDgDBw5gxYqVbuAzoBcwMPqdZhiGcVDFjjkXLaqic+cMWloUqak6sIld0I1E9C0W5oTDux63w2GCkQgNtk2108nWuDi2Op1UK8VOy2KHZVHtdLLd4aBRKcLoqv7vfW851DHAmOhi28BfEandzzr9DbjSAeShx1wVR+99IN1g+UTdc6c/uh9aA3pY2THo84WLTT8040hkqgSOIH4/ucC4+HhOdrsZ09pKEkBODvTrB6NGwaBBuj/N3iFOm9LJWOjQNmBwhMOwcSPMnw9z5hDYupUNkQibiotpzcsjvnt38rt3pyPQIfai+HhCaWk40tKwUlJ0iJOaSqPXq0McEVaLsNm2aY5EoLWVLHYHN4PRQ6r2DnAa2R3WzObbAc7OQyXA+Q9E2E8Fz4FeEMMwjCPMxUBFYyPzgNeAZxoaSAVOB+7Jy8OJHnb1SjTcGQqcFH3tr5RCgPOBocDFVVU4gQc9HiKlpUscw4f3pby8itLShVxxxYNcccXlrFq1KgL8Gd3TbooJdwzDONQUFaXh9SrcbqGhQeFw6FlvQZ8XWBa43bt/VgqiF3jjord26Au3Pwo7ImDbkWg3ZxulbsImyN5hkEg40hqWbVu21DXX1CQ7wmEckQgSDiORCDPHjVHbgsFeGyG7UDd+rkA3fAZ9bjEI3YvHzGhoHHEOaMCjlHoSfXWsSkR6RR/7PXAJsD36tJtF5O3o336DHgsfAa4WkfcO5PIe6vx+vMCwuDhOdDqZRLQBsdsNRx8NI0bAccdBSpsuM23H0u6nl44KhWDDBpg3D0pKqK2vZ6vXS21uLp6UFHJ79SKrVy/d+FgpSEoikpaGI1aJk5pKJDmZMpdLN6W0bWptm6Bt4wDSgkGKgZ7ACaBDqDYa2T2c9lO+3dD4cApw/p3p7LsHj/myMQzD+C+JUACMB+6wbS5EV5BOA65FH088CPwK/f1zuwgKuA99gWOmUnzR0EAKcDfwNfAP4FkgJT2dVo+nq4A4r732Kp577hlmzZrF9OnTufrqa94DrgemKcVLB3SlDcMw/gN5eamsX7+T9HQniYnQ2BjAtuPO8vmYhb7o6Dzo95blYPXqQtav74jTYdGtWxnNgUTq61MJtSZgWQrLYeFwWFmWtRmHY2vp5opuyunEcjiwHE5qbJulwFuQ9jLchQ76NwC17G60/PKPtZ0N42A6oEO0lB5b2Qg8s1fA0ygi9+z13B7oGS8Gobuefwh0EZGfbHWD348Cunu9HJ+QwBl1dfQPh3E6ndCzJ4wcqat0Cgq+FdrsL8whEIC1a2HxYuzSUmpCIWpTU7F8PtJpUz1jWUhKCiotTQdGqamQnMyO5GTWWBaVIjTYNhERXOiZp2INjRP3Wo0Gdgc4sVvbhsY1R1CA829Fy0uvYHfFlAB/N02WDcMw/jsi3Ar83rbp1NjIh8CmhgYmo/sxvJSXx3Xo75sPleI0ESYBM9DhT3elWNPQwIPAL4GBVVXkAG+mpkI4zKrMTLq9+up7y7t0ye2ZmZlJnz69SUxMkqVLl4bi4+OXAkOVwvR1MAzjkKCUsoBN6PMp8vIK+frrDbRrp3A4BBFFIMD8YJAT09PZdnCXtg2lBgEPoM9H3kOfQ+ytAljbCT6pBerQJT5tmbYHxk/NAa3gEZHZSqni//Dpk4AXRDe/KlNKrUWHPV/+SIt3SPL7SXM6GZuRwdmJiYxobMTX0gIZGXDGGbpKp1MnPcNVW/voo0N9vQ5zVq8mvGULDS4X4vGQgJ75ysrNJd3lIj1WiROdqaolOZktPh9bgeboNIdxQDpQaNsM2avZWj06wFkHfMS3Z6Oq/SkFOP8htdfPVyqlMCGPYRjG9yOCBVwEfNTYSA90O4ab0EF6POyaWcsH/FEEJ3Bv9OXTo+FOH+Aq4OGqKtYAM10uIk4nZT4f3Rob2eJ0BsJ+v5/jj59IXV0db731tmptbXUfd9zw5fPnzzfhjmEYhwSlpwi/Dx3urAE6b968kWnT7uKyy24iJ0fhdEJCAgM9HjbX1XFnTQ23FBcfAsfqIt+gVATdB20Jel9dhcjeGQ7r9PNM2wPD4CA0WY4GPG/uVcFzIToYmA9cLyI10cqGr0Tkn9HnPQG8IyKvHNAFPsD8fpyWxaDcXM5pbeWE7dspEtGBzmmnwbBhOtDxene/pm2YE5umsLoayspgyxZCO3YQiURww+4myV7vruFUJCdj+3zUpqRQHR9Ps1I4REhET1Uet9ci1rLvypsNwIb4ePbZCM3YNzOTlmEYxg9HhLHA+8DU+np+BvgDAbqFw6wD5uXlcTb6u+sTpThVhIuBx9AzLBY3NrKD3Y2Vu1RV8Qfgl9nZhG2bsNeLJxTiF3FxPPrQQ3/lmmuu4aGHHuLKK6/ilFMmMXPmTLPvNgzjkKGU+i1wB7oS5jqJnviVl+MENilFdm6ubrQcnbZcBQJUBgKckp7O1wdz2QFQKh8dyj+ISMX+n6YbLu/jT6Yy3vjJORQCnixgB/p/wNuBHBG5SCk1Dfhyr4DnbRF59YAu8AHg91NUWMhUh4OpW7fiDwZxFBfDxIkwdCh06KADmX0NuwqFYPt2PTX51q1Etm3DEWmTVScm6kqclBTw+QgmJ9OQkkLQ68UFpADuvRanhv0HOOUmwPlhmZm0DMMwfjgivAiMaWxkuG2zDLi1oYEqdG+zkXl5DAP+iJ5VZTX6ey4DuFkp/tzQwPnA08DPq6pYCcz1+VBAWUYG7Xfu5O9paUxetmxZ9qBBR3HyySfzwgsvcu+993DjjTdGl8Hsuw3DOPiUUpcBDwP/BC4QkT1q7svLOQ741OmEzMxdk7CEAJcINDUxs7GRKbm5tByExf/e9tH2oK1pJuQxfioOesCzv79FGywjIn+O/u094PcictgP0fL7SSgs5MSkJC7eto1jW1rw+v0wZIi+FRfrnWxbIhAMwo4dUFEBW7fqKp1wWAc/SUm7ghw7GuTYKSl43O5vDcPbyX6qb9ABTt2Pue4HQ3SHfxm6UiYCTD9UdvKHQwXPobz9DMMwYkTIADYDD9fXA3CFbVPc1MSnQF1ODqMtiw3AHKWYJMLNwJ+AKnT1jgcd+qzfuZOR4TCLHA46paayJTGRgqYmypOSWAxM6Nu3jyMQCDjmz1/A0qVLGTHiOMJ6TuFDZt9tGMZPl1LqTOAF4G3gVBEJ7et55eW8Ckz2eLBTUrA8HhAhHArR4HaT2tpKS1MTV6Wl8cSBXP7/1uFwXG0YP7aD/h+6UipHRLZGfz0VWBb9eSbwnFIqNm60M/DNQVjE/5nfjyou5ujMTK6pqeH4Ll3w9eyppy4/6ijIzt49q1XsvqUFqqpg0yZdobNjhx56lZysg5ycHCLdu2MlJ6N8vj168NSw7/BmAzrAqT+wa39w7aNk08Gh1ePmkJ5J6zDYfoZhGDHnAu5IhOeAD4CXm5o4Gn38MMWy+CV6EoA/RsOgW6Kv+7VSBPj/7J13eFTV1offNWcmjTQSCEMQCAIasIAoVhS7194rXq9drFjwer32Ltd2VcR+LZ9d7A1sFFFAFBREghAgIL0mmfScWd8fa0JCSCaFEIrnfZ55JpnZs88+A9nn7N9e67dgGBbNc3RlJTcBO6enExahQzhMODaW5zBB6Pq8vLydxo4dN7isrIyzzjqzStyBrWTu9vDw+OsiIkdgUTvfA2fUJ+5EuBI4uryc+Px83MREnIQE/DExpFZU8JXjcFhqKi+EQlxfXMyxGRksaI1z2ATqEneivb5F8TZRPTYHrV1F603gYOwGajlwR+T3vliK1gLgsirBJ5I3eiFmiH6tqn7RaoPdRE46icwuXbg5HGZQXBxtd9wRdt8d+vSBhARrUyXolJWZiLN4sUXm5OdDmzbVYk7E7JikJPD5WAfMY+NKVAswAacuh/m/JCISAEqo33RtT8yRv+pRpq0d0gaIyErsb6KKVaravpXH4GAlg6seyZHnUdTwbqqBi1VKWxUxQvfw8PDYYkRKnc8AigoKeAl4WpX9QyEeBTq0a0e/2FhygYkiHKfK48A1QA6wayjEbsDPmLHyCODXxET8jsPi9HQ6rV3LU23bciEwAfgb8Cxw8THHHM2oUaPAuzH38PDYChCRfbAiJ7nAQFVt0FohL49rgMf9fioDAXxxcfgSE9dvOr9aVsZucXHsUVlJOBRiRH4+Q7KyCDfU75ZgW4rgieIb5KWTeWwSrZ6itSWIpHcdWeOlL1X1qJbs7x//0BO6d+fWlBSuCQRIDgZN0MnKsgaqlk4FVs0qLw+WLQPXNTGnhpATatOGhSLMwdzuF7ChgBNq7ri3NyKiRCZWJaUbVpa95vMO1C1O1EclGwo+m/TQOlz+6ziHX4Hd63hruqr2ifI5waqf1RRj6hJoGnqt6vXaZtpNIYT5aK2OPNd81H5tNbDaE4U8PDxaElX2ASapcmlhIUOAssjzd8BVnTqRBDyAVeNcCczFFgFHhkJ8E2nXs7KSXmvW8JnPR//UVFYlJ5MRCjE3OZkCTNTeHTgceOWJJ55Yce21QzJqDCPqvO3h4eGxORGRXpgIvQ4YUCNDIioRw+VfgOxAgCV+PzvExiJJSev9P8cWF/N/gQBPBgIklJSwuriYs9u146vNdS7NZVsRTSJrmDK2ETHKY9tiuxd46hBjqmiWyFPVX0xMPFdd9SwDB56F3+8nPR1695b10TklJVBebhPjqlWwfLmJOYmJVKSksDolhXlt2vArMBOLxsnDE3A2ICJiBKkWbGqLOF2Amm5FCiyhOrppPnALdYs8YeB06hY8Gno0dtItZUPRJ8TGQtCQKJ9/uY5j1xRpGjuO4jqOW1DHa3W9Poa6Lz5hzMiuHZAeeW5X6/fkKGMqJLoItJFQ1ECIsYeHx18YVZ4Hzg6FOD0c5nPgwsJCTgIOSEmhV2Iis4AfRThGlXew+X+cCAcXFvIPbL69cMUK2gBPpqdDIEBlIIAAzwYCXAGcXFFRMcfv9/84efJkDjxwQILrblSB9zegr6puFaV5vfB/D4+/BiLSBUvJCgAHqGpuUz6fl8eBwHjHAb+fL30+joyJQZOTQQQB5qlyZEkJD8THc7oqhEJ827NnMHflyuUXshXNMbXmPYCnVfWKzXg8H1a4pl0dj9r3yFWPttRtBg14Zv0em8ZfQeCJdoL/wqIgYrFqUjWf/4aJC1WsxcwX9508uYQuXWLJyxO6dbPUqaIiKC4Gn08pKNBwKBTOT0xkZkaGf0JCAhOx3cK8hASKNsd5botEBJx06o/A6QrE1frYCky4qSniVD0vrB0Z0tJKfq3ImZZ61Mcimi/MrBeVGhNJFOV8m/39iUgM1Re2+kSg2q9F+z4KaJootKapotD2sBhq6YhFD48tQVP+FlVJBJYC7xYUkAwcUlTEoeEwvwB3d+pEETBs3rx5h8yaNStw7LHHfqmq3HjjjZd+8cWokrFjp4xYvXrVqkGDznjvjTfGXZuUFPCXlxeUZWWlxL788ttLzzvv9I6vv/5a4ZVXXvvuw2sAACAASURBVFk+efLk9LS0dPbYoy/Lli2LdgolmKhfFHkOtcDvxU1JI95WdrI9PDw2DRFpj0UhBrG0rF+b009eHq8A5wYC+ER40XG4KBAgnJKCRESeAuBvxcWU+f18FBPDDqFQOf/6182MGPFoza62+BxTR4R8oyIsI/f5KTReqGkHpFF/xkAZFjVa173qbfV8zovg8dgk/uoCTxUuUI79EZZhf9i1hYWqds6YMSuJjU2nb18hNtbMkAMBE3pcF4qK8lmwIJfp06eTmzu3fOHChWvnz5+3LCdn9sLVq1ctBpZhHkTLa/6sqtud+CMiqdQt3lQ9t6n1kTXULd4sABaoanEzxrDVLtq3hTLprfn9iUgs9YtC9QlFiVG6zKeByKAaP9+AeX7VplVuVCI3FTUf1Pq9Ma9/ABxaR/ebFLG4qf14eDSFKMLEG8BwLDpw/eORRx4ZeN1115949dXXfHX33Y8d/uabryxwnMSEI444IeOww3ZZ8uOPkzKnTZsqf/vb3xg7dhwHHnggb7zxBn//+7k89NATXHzxFQwcuBdDhtzPQQcdhd9fEO7SJdU3Y0ZuaTCYKOXl5RV9+vT55P33P9jzwAMP3Onaa4e8MHz48IujnMKd2LyUiF3jEuv5vQ0bXwOjoVhEZmMFoTvwFg8eHts1IpIEfAvsChypqt81t6+8PDoAf4jgBAKsAz51HC6LiaEiORl/ROSpBM4H3rjlljsqb7/9Vl9MTICZM3M59dTjmTNnFthcNR5bW1VEHuWNfG6JtqOB3nWc4nxsXowWaZNO/RHyFWx8HxntHnMVUYR5T4T32Fz81QWeBKC8dih1I0UhTjjhRk444T569vSz//6CzwehkHnqAKgq4bAgAr7ILdbKlSt17tw5MnfuXHJz55Kbm0tu7lzmzp3L2rVri1S1TvGn1s9bjRgkIonUL95kYSGLNSmk/gicBar6V6vy1SwPHo9qRCSODYWfhqKF0mnaogrswt1UsaWxr7cW47DzWNPQs6qWtXR6q4dHY4liklknEyZ8T1pamo4c+UnRVVfdkHjssYfOfP31L3t//fWnC4qKFq0eMmTIXued9/eX27VrV/7oo49d6rque9JJJ1642257+W+++Y7nV65c8drixSUTOnXKei41FeLjcR0HdRw+dxyOAfYD9gCeA24X4Z6WEucjof0J1C3+1CcMNaZtVF+1rWUDwcPDo/lENsU+BwYCJ6nqp5vaZ14eVwNP+P24jsO7qvj9fk4LBChNTiY2IvLwv//9b84ll1zcMy0tjXff/ZiDD96fioowL774GkOGXExFRcV4LF0spp7n2q81xTOzJXBpWJyp/X5hSxdjqbWJqth94ZGqutX5G3lsO/wVBJ4mL1IaEHi+rN1f5877cMopH5ampQXjTjwRdtvNSppXlTxXrRZ4VAlbFIqKz+fbYJFZXFxctmTJ4qLc3NzKnJwc3++/z4zLyZmVmJubW1coeIg6hB/qEIWiRb00FJ0RWTxnUb+IU7P6E1hYen0ROPOBtVuiUtXWTHPDSD2aj4jEs7Eo9FaUjwyPPGutR2u81pS2j0Q5h7VYzndjKCKKCOYtDj02Jw1cg4/BIvMKgIKxY8d1POiggyapclNhIUOBiYWF/AbcHAjQJyODr4HpwFGY5102MCwU4t+YGWmPUIh9i4v5OTaW1Ph41qal0baggNeSkzkX+DfwBTAJE0mPFiG8tYvznoGnh8f2TeRv/B3gFOA8Vf2/lug3Yrj8M9A1JoYUEQaFw+7lgYAzwHWLKzIy4gMScV7+8MMPOffcQRQXF3PccSfw0kuvkp6ewooVBYgkn5aRwXtNPJ+6hJ/6XosmHD0f5VA9MbEmf2tbj4hIAjAFS/nqo6ortvCQPLZRtnuBB5qeZtDQzlx9/d11F51XreK1efM48JBDkHPOgWDQBB4w0aeiwp5jYwn7fKZWq1IqwmIsukWwRVgnatyYua5bUlhYuGz58mVr5s2bXzRz5m8V06ZNlWnTpsbNnTs3NRwOd8AWqXURou5ooIOBQ+poPxvbzc8COtZ6rxwzhK5LvJkPrNzaJsxtARGpwP4evZvuLcS2VFqzPhobfViD8cC12M1Eeo3ndOC6+j7kCTwem5Om/C2q8ghwdSjEteEwT7kuJxQX8wowplMnJgCPAgcCnbEUrwKgcyjEKcBLwAUrVnAYcG7btoRSU0ksKOC3lBSygKnAidgNdzywhwgra4xzqxbnvfB/D4/tk0hK97PAJcB1qvrfluw/L48BwHeVlaWrfL5w8kEH9S5+/fXPU3v16k15eX5JZmZKfOReX2bMmM6xxx7L4sWL8fv9DB/+LBdffAEghEL8GApxQqdOLG/J8TXEtmB/UB8isht2zfkGOM5bU3k0h7+EwNNUNjU14eGHSVy0iKcmTOCcdu3wn38+nHgixMVtIPa4paVISQk+x0Hj4ymOiSFOZP1N7Wrgd+BPqoWfjkAPYEdMqa6iDJjvum7u2rVrl8ybl7vmxx9/LPr66y/Lv/32W6e4uLg9ZrzWIfIIYgu5aIyhbhFnqaqGG/oOPJqGiJQDjqo2Oi3Bo2XZHhZDUeaueqnvZmdbvkHy2LYRkVFYxE1tNvhbVCUGWAyMKyhgByC1sJBngMcch4ODQd4CZmFFExZi17+rQyFexzYy5qxYwT3AF8nJkJhIWITKQIBffT52wsSbh7Ed8oNFmFDHWLfqubuOajIvqWpdXmMeHh7bCCJyP3AzcL+q3tKC/QqwJ3DO44+/ftkxx5yWAOXk5eUuP/vsowZPn770KceRzPh45rdpQzcgHA6HfatWreL4449jypQpLvBMcbE+5fPxSUwM3cvLcQsLuT8U4s6sLFpl/bC1R1g2hIhciUWOX6uqj2/p8Xhse3gCTz20hLnoyJH4Jk7k9qlTGTp9Om1OPBGuvRZ22aU6fQtAlcrSUkJr15JUWYkTF4cbH8+q+HhwHNqLrM9LXYypuj9hgkshJtb0iDy6R54TagzDjbTNxSp5zQXmLl7858KddurxS1nZBkWn1uMt4FoXESkFYlS1tXOQPWqwNRtyN5a65i6iiD5RBB7Pg8djiyAiYzDPm0Si/C2qchrwbkUFQ0pKeFyVa0MhrgMWderEu8DjWKTqHsBj2IbJjqEQjwGXV1YyYM0aRgYCZCYmUpiaSlJRER8lJnIicDaWvvkkcJMI/6lnrNvE3C0iPYA5wM2q+uCWHo+Hh0fzEJHrsXTs54DBLRHhISK9sDnvbGwdUdGpU9dvx47940DHcfLi4pxeItwQDvOC45AnQmqbNvyWkMCu2CazHzNf/ocIbwOoIqWlDAkEGObzEVNUxNJQiJM7dmTypo63kedUW+QpUtVoRTm2GiJC24fY5sS+qjptCw/JYxvDE3haiVtv5cJffuG+774jmJoKd98Np5xCZUIC/lpij1tZybK1aykrLCRLFV9sLOUJCeS1aUNJTAxtfT461+g6FxN9qh5TscoiNQWfmo+Uqg+Gw2H+/PPP9SbP8+blYubPue7Uqb+kOg6hVvhqPAARKQbitvZFgse2SXOjcbwqWh6tjYjshEXX3KKq90drq8oooHdBAWOAU0Ihhqjyos/HaR078gQmaJyAbY4kRtoswDZJnlqxAhe4NiWF0vR04vLzmZGSwi7A65iw8z1WjeVEkbp3nkWkCEjYFjZFRGQcFgm8sxf27+Gx7SEi5wGvACOBs2oXiWliX12AszBRpy8QxqL33wTeV9W1eXlcBTzp9zPFcegD7BkOs85x+EOE+MREfoiPZ39swzkBE+TvAu4SMa/AigpSXZeRMTEc5rpQWMiHoRDndulCqxSLEZGu2EZ3uarGtsYxWwIRaQf8in23e24txXU8tg08gaeVufdejpg+nf+OHUvvkhI4+2y46SbCWVkUi5BY859DFQ2HWVBYSN7atbSvrGQXAJ+P4oQEfk9MZFV8PLGOQw+R9aJPGEvtqhJ8fgKmOw5lrotgqVk9gB6vvvrKNSKyd48ePejevQcZGRm1h7ucGlE/1IgCchzWbqav6C+JiBQCidvCIsFj28OLxvHYVhCR/wDXA51VdWl97VTpAiwIh3kkFOJqVV4MhdgPiM/MZIQITwCHYqleNwG/lJSwp+syAei+di1nV1TwdWIikpKCqlIWE8Mynw/Fon7GY6nRe4iwJsp484HkbWHurrE4HKiq47f0eDw8PBqPiBwPfACMBY5V1bpD8KP30R44HTgHOCDy8mRM1Hmn9pwbMVyeAmTExBAQYSmwdzhMT8dhqgj+pCRGxcVxNGZcnI7Nm+8A54tQUtVXaSmHOw5v+f2kl5RQUljINR068EJTz6E5iEgIKxzRVVUXtsYxWwIRORT4GnhRVS/Z0uPx2HbwBJ4txCOPsMuMGTw9ZgwD1qxB+vVDb7sNGTiQlT4fsSIk1/6nUSW3uJgpa9ZQWVpKP6B35K0Cv59JycksTErCDQToIkJ/qitclWNVRGpG+sxyHNyaKSlJScnugAEDRn7yyWfvsXHaV6dap7CGWqJPjd9XOA7ef6xGsrUbdXpsH3jROB5bOyISg6VRfa+qJ0drq8odwB1FRTzkuvyzpISLKit5UYTLMzO5FZgHnIkVBQgA+4dCZAP/U+WiVav4p8/HzsnJlKSmEl9czPg2bRiAGTL/CwuNP1Ck/nSCbW3ujlRoWYbtzp+/hYfj4eHRSETkICyacAZwmKoWNuGzycDJWKTO4ViUzUzMdP4tVZ0X7fN5eewPfC/CyJgYTgMeCgb555IlDPT7+RbQ5GRGxsZyJhYt2Qmr6vkzFv24pKovVfylpTwWE8OVgBQWMjMU4oQddiDqGDYVESkAkmq8tFXP1TWp4bd0hqq+u6XH47Ft4Ak8W5gnniBj1ixGjBvHSYsW4XTrhl51FXLuuZTExjIPyBKhjSqKqeJV/FlZycdr1rAoP58dsWpYPSLvrQHGxsfza1oaBfHxdIwIPntRPcEVYelcVVE+U4Dc+oQZ1yUBM3euK/WrC1AztShEPZE/wBLHaR2TtW2Bbd0IzsPDw6OlEJHTsZ3fY1T1i/raqeIA81T5o7CQnYC5hYVUArt37MgDPh+PA0cA5wF/B74IhRgE/AHMXrGC0cDdKSlUpKcTWLeO31JT2RW4GwuHfwgYEokCqm+s2+TcLSLPAucCHVW1YEuPx8PDIzoi0hcYBywFBqjqqkZ8Jg44FhN1jgNisTSlN4E3VXVGU8aQl8dLwLmBAO/7fJwOHBIMMm7pUk53HN4BylNTeSkQ4DJMXN8RqABWAieI8HPN/ioq2DEc5pOYGHqXlxMuKOCpoiJuyMqioinjagzb6lxdhYgEgO+AbKx0et4WHpLHNoAn8GwljBxJ3A8/8NAPP3DRzJnEp6fDJZcQvuwyfGlpzFSlEOgnQowqYTYUVFYD7xUX8/WSJbRRZSAWmt4l8v5yLK92bLt2LEhNJSMi+PTH8m7jIu3WUi32TAGmOA6LGxq76xKDlVSvHfXTA+iG7Z5WUYpN/nUJQAsdh8rGf2uthEhbYAds3L7IQ+r5Odp7G/3cB6bX9+GJMKCRfUV7bwBwGHA8DezSeHh4eGxJRORLYGdgx2jeEqocCYwuL+fh0lKGlpdzfVkZj4pwW2Yml2EVsy4EZqGqiOwcMV8eXFzMKaEQIxMS8Keloa5LaVwcZSLkYKlc32LmlqdXeUjUHCCRuTUWyuubhNda9Gxd83RDc3fN3/fBIpD+geqfm/C11j6FvbGUjMtU9bmW6tfDw6PlEZHumBdYBXBAtPQiEfFj93tnY5X/krD7/3cwYWdSc7238vLIwATyqTExdBYhBtg9GCR/6VKudhyeUKUoLY3hfj83YdULe8H6FK3zRBhZs09VpKyMS/x+Hvf5iCsqYk1hIedkZjK6OWOsj+2hIqiI7Aj8gkVwDVTVrW+t5LFV4Qk8Wxn33ouUlnLj5Mn8c9Ik0uPj4eyzKRsyhNisLFYAk1RJAw4QQVSpxNzrqwgBn6jy1qJFzCkrY39M7DkEM1cEC4EfA4wJBBiflUUSrBd8+gO7UV1SdSkbiz6rG3s+rosDdGbDiJ/uNZ7jazSvxEqx1077mgsscByanG/cIohMwgSskViOcYtxJ9wR5b276ng5XOOhDfwcxHZqdwCeQ/XyFhy6h4eHR4sRuYHNBe5Q1bujtVXlHeDQggJ+BXoWFjIeOCkY5DbH4VHgKFRvBA7n5ZeLKz8f/ULp/9682vfjxDGrErvtGM4IZrVNcd2kVMcp/3Pl0rhgahqXXjKCJ568kMrKSvbY40lZtLCcjcWX9dzZ9Lm7KcRiHhk7AI+jev0m9reeSHWW6VhFmX1bql8PD4+WRUQ6YuJOMnCgqs6qo40P2A8Tdc4A2gP5wPtYCtbYlhID8vK4Ehju8/HvQIB7gDeCQc4DWLqU+xyHf6uyOj2dRx2H+7B5ZjcsYyARuA24r7ZwrkpSWRmvx8RwfMSE+dvCQs7o2rXxa41obA8CD4CInIMVALhbVeu9/nh4gCfwbNU88ABnTpnCg2PHkuW6cPTRFA8dSny/fihW+jhPlb1F2COSwlWO3RhWUQ58BbwVDvNZbi4ZVIs9h1Dt0TMf27UcA4zp2ZO1WGRPleCzFxYaSI32G1TuchwanQ9cheviw0Sn2ilf3YGebJgvq9iubF1pX/McZzO68YvMiYxrIXAqTRNZav+8we9psKq+D5Tav2X1W035YxXZDfgP1kc8cCOqE5r7FXh4eHhsTkTkPsz7pqtGiVhRpR2wJBzmzVCI81yXYcXF3CDCiMxMTgKWYCbNP1Baqtqls5S8P7o0vHOv8uIPR38SOuykQSlJbji9veMrWJS/JLlzSiZvv/UkBwwYQMeOu3LTP2+URx+dQwPz9/7wXV1vhoFfoU9dn2nk7+2A+yPPscD5qP7eIl9yBBG5DngU2FVVZ7Zk3x4eHpuOWOT4OCzV6VBV/bHGe4LNMWdjVbC6YJEyn2CROl80x4C5IfLycKg2XH5VxHxhgkHeBVi6lJf8fs4Ph8lr145HfD6ewKwgemMRSEmY6HSRCKW1+y8vZ4AII/1+OpSUUFFQwM2lpTyalbVpnp6bVeCxSldr2YRqZk07nLyMpR0f4hnle0TDE3i2AR57jAOmTmX4N9/Qt7AQ9t6b4htuIHzUUSSKMAd4DwiocqoIWZGonnKsZGEVYWAC8Dbw0Zw5LAV2wYSeQ4GBQGqk7WwiYg8wNjubFa5LMrAnG0b6dI20VyCHDUWfXx1n4wm8sUQqfrWj7rSvHphTf02WsnHUTy5W8Su/ueMAQOQC4N9YKtxrqA7fpP426Hoz5AZbmeFHARdbMJ0JjEJ1UnPH6eHh4bG5iHgMLAR+UtXjo7VV5Trg0aIi3nRdTi0s5EXg0owMbgkEeBA4BhgG7MZ7742uGPX13mWPPd1Wf5t5/8qMXa6PjyeuXTuoqKA4Pp4YET7AStHeCwwW4dlGjnlzzN1pwHDs2vccsCvwakun10bK7y4BhmsLRgd5eHhsOhEz9C+BvTE/sq8jr/fARJ2zsfSnyki7N4GPmmK83Fzy8tgP+AF4ODaWgdi9+W7BoBkpL13KKL+fo1yXXzIyGC7C85jI0w0TrNtgKaInibCsdv+q+MvLuc/vZyjgKyxkfmEhJ3XuzPTmjrnBudqioKo2Q+Mx24rG/LwzNkcXAJe2ZCptfYhIEvZ9xmF+PPVWePT4a+MJPNsQzzxD92nTeOabbzhs+XKkZ0/KBg9m9XnnkRkTQwk2yX8P7KXKGSKkq1KMXQSSa3X3Cyb2fOg45OTk4GA7AlURPgdhIZUAv1Ed4TMuO9tKpLsuGVh0T/8azx0in6nAckVrij6/t5THjuuSyoaiT82fO9Zqvoq6K37NBVY3WPFLZCD2nbTBRK4HUP2qJc7Dum/BSiwiWcDjWDrB9dg5/hOYieqnmzRQDw8Pj82AiJyElf89UVU/rq+dKgL8pkpxYSHZ4TCfFBVxPPBJp07shxl63gt8BKx1Dzt8aMkbHz7pmz+vdN3ysoqy3ffqkJ4ulYmJ+MvLWRQXhwBXRo79FnDuRr470cfdknN3MibudIycwzRsDv8M1SnN6jPq4eRdrBx8J1Utb+n+PTw8Gk/Nirawfg46AxNTzsREnf6R18djkTDvNcZwuaXJy+N/wN8dh+P9ft7HDICPDgYJL1qEBAL85Dj0c12+6tCBl4FXMRE9HbMOAFiBmS//UtcxXJfOrstHgQB7lJdDQQGvFhVxeVYWxXUOyqKaYqhHjDkRXg3DjlUvZsCfD8PDkV9j2bCITW0qMP/QksijFEjBys13ozqV9sYGv7wWQET2wv5ffAKc1lxfJY/tG0/g2QZ5913aTpzIk2PGcMbcuQQ6dMAdNIgF115Lx5QUEoAfgWexPNzTgROBOFXWYpE8taNf5gLvYsaSPzkO4ZwcApiYURXhcwA2ESp24zkGE32+y8629KxI1M0ObBjlsxc2EYJNjNPYUPSZ29JVtVyXNlRX/Kqd+tWFDSfyAuqv+LXUcVDMlPIY7Ob7cSANuBrVuS01ZhG5GngCaN/sC7ZIp0gfVSlZMyOvXwS4qL7cIoP18PDwaEFE5HNsg6FrNL8IVfYFJpaX80ZpKecUFTE8HOaqdu24MzaWO4ETgKexMr0XFP/422nh7N5Hl0yY8lRh9j5XJyeHtV07n+TnMy8lhW7AacAIrMBAfxFCzRj7pdj1dgdVbbAoQT2dtAGexKJih6H6ZWTB8m/gJ1Rb1HTUDilHA59jC4T3Wrp/Dw+PxhERd66s460/sblMsJLjbwJvR0thbQ0ihsuzMcPlkSKMAK4OBhkOsHgxjuMwx3Ho5rr8X4cOfISNfSZ2LlVRL7HAIPHJZ7B+89dPDYGmYvzE02Wf/nc7ASc+tK6yuPK1t55oe83ff6LuiJoNfNJq4RZB5U1wf0/4cIh5atYUbOr/ufY1SSQeeAFbS/2ORVNd0hoRPNVDkKFYtcfBqtqoqFOPvxaewLMN89NP+D/4gPu+/54rfv6ZxKQk9PjjmXvzzfi6dKE7Vi79RcyUqy8wCHPY96myGNspCNbqdhmW8vUhMM5xrGRhTg6xWLhoVYTPfpha7mImzFURPt9nZ1cr7BGfnR5UR/j0B/pRba6cT7WJc9XzogajapqJ6xKLKe51pX1lsaFhdQmQy+pVK5g0KY6+e7zHnDnLfNdceTF//LFKKisvooVCYjd5kSDSHngKi9S6BdWfa7x3ItAT1YdbYqweHh4eLYWIdMHK996nqrdFa6vKC6qcVVjIYlXyQyF2AH7v1Ilu2PXuBeAZYH4oxBmo/uj7buzPy3sd3DM2VlIyMpTyoory+OSYGBEewq5L+wJ7i/BbM8d/PvAS0E1VFzSjg1hMmO8J/JeaEUwilwP5qL7RnLFFP6w42Pc+Q1WPaen+PTw8GoeIVFJd2KQ2d2Jlzf9ovRE1TF4eV2D3nGfGxvIPbG3QLxhkFsDixSQ4Dgsch/auy386dGA8traYg0VaHgIsRjWTBx/8k1tviRHV12FjP0/NyIip+ODTE/z77rVLOCwUzl6cF3/B2U/FTfluGY0VaaACVRWRpcBnqnpxs07chPeHsHXMg9im+X7Ag6i2eIn3KMPwAV9g2RZ7eV5qHrXxBJ7tANdFhg3jiokTuW38eDo4Dhx8MPP/+U/y9t6bAzFVexS2UzkNC/scBOwZKbmei4k1VZ46VWXY84GPMbFndE0j45wc4oH9qY7w6Y+JIxXAJKojfCZlZ29Y/cp18WOmazUjfXanWlxZwYZRPlMch5Ut8mVFITKuLtRO+yot7Y3f6YY/UH0BrqhQVq9eR4cOPyBSO/Urz3FoUsi7iPwDeBnork31WzAzvqcw34Y7UJ1Y6/0BwOHYBajZvkgeHh4eLY2I3IVVV9kxmkCiShKwNBxmfCjE0SUlPF9ZySVpaTwcH89QLBrnRSBFlSOKiriX8vKehT/MWFrSu98u7dvjJiTguPmhihifu4DU1HeAW4DzRXhlE8Y/CHgN2LnJizDzHnoUqzTzNKpv13r/TKB9S/q+bdi93INFCUU1tvbw8Nh8bItVnmoYLnfw+znIcZgM5AH7BYN2/7tkCe0ch/kiJIbDXNehA79ha4o8zCbiLFTnIbIjr7wClw/OldLS86lHpKksrdhVff73/X46l5TgFhQwrLSUO7KyGm/9ICITsQqChzfrxE10PxN4G9WnEemJrada3Cut4aFIEKtUtgzYW737e48aeALPdsbjj3PCpEk8/M039Cwpgf79WXLZZUw+9VT29fnoiE2szwD/w1KNzsFKaXdTpQyYhXnN9Ix06WI7C2WYSPQh8EntUuk5OSQBA6iu0NUPE4lKsVzRqgifKdnZbKRyuy5xmMhTU/TpRXU6VR4bRvn8vMnmyY1FZAd1nEv0hqFf6/0POkAPvv3mVMLhvdht91I6dEil2q8ITCDLo+7Ur3mOQ8nGh5CzsBDW3nWVwowytiRM3MkE7kN1TB1tsrFKC8/T3BQCDw8PjxZGRPxYVcaZqvq3aG1VuQh4obiY8RUV9AqFWAWUZ2aSKEIB5kdwOzA5FOJ54IWKmbNfXtt+5/NTUlTT00UK8sNLk+MqMrjzzlncf/8uiLwkwkWbeA6nA+/Q1IpUFkHzHywV+iVUNxaZRA7HdofvQ7VFU5mt+/Wl6W9V1ftaun8PD4+GiRLB46qqv47XtwpqGC4/FBvLRKw0+33BILdWtVmyhO6Ow+8ixLguZweDLMZSQ5cDnwHXsHbtCtq2zWDq1EKuuvI6mTjxxfqOqYpTUcEtjsNtIvgLClhWWMjpnTvTqCqxIvIm0F9VezT5hEWOxAqXTMVsEDQSgfkvYHyd99+bmRqptsNV9erWPr7H1osn8GynPPcce/74IyO++oq916yBnXdm3ckn88XQoQQDAQ7Bqmy9i0X1TMTC1M/FlOn0iF/P75h/zq6RbiuAACb6jMfEng8dh4W1j5+T7x6L4AAAIABJREFUQyoWOlgV4VNlRFmEGbJVRfhMy86mzvKCrksSJhTVFH261Wgymw0jfX6pSzzZZETSgauB91GdHnlNiNycq+PcHy6rnEHdaV/dMSGtJn+yodfPZL9fUrGL4x6qWqfpXB3jisd8gbKAh1AdVU+7dsBVwAeo/tqovj08PDw2MyJyHCbMnKqq70drq8pEVdoVFrJjeTkjy8o4IzWVZ9q0YTBwHvA8EFtZyYDSUj5SZfbqZRU7+eMD7Tp2VEpLpSghgTaSt+A/pKZeS35+CS8830PuvbdZnmeqdAfyfD45DjNp7qeq0xp74lgp9P2AN1B9rp52e2Aeeo+jurY542zEUL7Fond76mYQkTw8PKITxYPnKVW9qrXH0xTy8ngRm3/7xMYyFPgHcGAwyA9VbZYsob/jMFEEcV2OCAYpwjaMC4DnUL2b1avzSU5OZvXqCh5+6Bp59NHnox3Xdcl0Xd4NBNi/vBzy8/m4uJjzs7KIOk+KyAPADUC8NqW0uW2U/hcr2nIJqiU13rsUKN9SPpci8hhwLXCCqn6yJcbgsfXhCTzbOe+8Q+fvv2fE119zzMKF+Dp1ovSQQ/jovvtYk5rKIMyz5VdM6HkDi9Q5Egs5PAmIV2URFtmThu02SqRdbOQwU7Eb3A+wSlkb/afKyaEdVrGjKsKnV+StfGAc1WXZZ2Rn12+67Lq0Y+Ny7VVVsyqxil9VUT5TgN+qfISajZWs/CfwBaqTa7xeZbSWBlxZX3im65JGtfBTWwDqAPyf3y9vYbsZ+2rNY9Q/pljgMSAbeALVD6O0dbBUhO9R/abBvj08PDxaARH5CNgH6KxR/AtU2QX4rbycb0pLOaSwkClAZmYmJSKUYHP+RcD7oRArgEvWreOt8nIGZWSENT5exHWlPCaGL4G2VFb2Y5+9p8u0aROo2oltAqochKUaPO3zyXfY3L2Pqv7YmJMG7sCuh++j+kSUtl2BC4DXWtLUv9ZwzgX+DzhEVcdujmN4eHhEp1YVLRd4ZmsXdwDy8mgP/AFMi4nhRBF+xYqx9A0Gq/10lizhGL+fTwHXddkzGMQBvgLKmTr1BXbd9V+IrKGoKIWYmABffDFUTjv1vw0dv6KCU0X4n+OQHApRWlDAdRUVPJuVVbePp4hchmUxdG50WqpICnavHw9cjuqiWu8fha1FHtzIkLkVEFsPTAI6Y6XTvUh9D0/g+avw/fckfvopj40bx99nzCC2bVvc/fZj1O23M7ZXL87FKpgUAK8AT/t8zAqHScJEnkHAEZg582/YZB7Eon6q0rDiIoeag0X2fABMrq9CVk4OHakWfA7FhA+A1cBYqiN8crKzoxsuuy6d2LBqV3+gbeTtUizXt2akzx9NqtxlZma3A2OpfQNsZclHYN/dRagW0QQiUUrxfr/sjl3sBqrq+AbGE8DKO/YBnkH1rUacw1XAyo08Hjw8PDy2AGJV/xYC/1HVm6O1VeVRVa4KhSisqODXkhIOSU7mtaQkzsUWRSMALSnhONflc9flrdWrOSslRSU9XShcV7kuKdVfhkWtXgWcIz5Jw6pMvo5q1N3iWmM5BdsMWQAc5fPJTsCXwIGqGj1NwMSdm4C/YQaZ/4kqLokkAkOpvbnQgohtVCwFPlHVv2+OY3h4eGy/5OVxOTYHnx0by5/Ypu1LwSAbGBkvWcL5fj8vqVKiSnaHDiQB3+C6foY9OI5/3nQwPp+PxYsdOnVKYu7cB9hpp1tEoq8BVGlTUcFwv5/zw2HIz2dWYSGnZGWRU7ttZFPhhMivDQtptkH6JLATcDuqP9TRpsoG4SVU86KNdXMhIjtjm+2TgSOaFJ3ksV3iCTx/McaOxZkwgVsnTOC6778nJT4e7d+fSeedxzOnn86R2A1vDCawjAA+8vmoCIcJYulbgzABRVWZgPkndMHSsXxAMdXlCpcBH2Fiz5hoxsM5OXShOrrnUEyJJtLHmBqP3EYIPoKVSa8Z5dMP8xYCc+n/mQ1Fn7yolbtE/gX8iuoXdbw3ENuR/RW4vqm7wdaFvAecUnUK1HfRsYvNg5FzehXV/zXyAGcB6ag+1dSxeXh4eLQ0InIrcA/QQ1Vz62unSizwp+syv6iI/qEQ41Tpm5nJChFKgUXAMao8XlTEfqp0Xb2aIr+fHTt2VEoKKioS28YEgLuwefppEa6IiC2PYQbHd6L6XUNjVuVyzPNsMnCcCKsbPXfbSV+LbZp8C9zT4LXCxngzMK3Oa08LISIjsEihjqq6bnMdx8PDY/sjYrj8I7bxmx0by83YvHVyMMgG0eVLl3Kz43C/KvmqZHXoQAaq31BSks4nH9/DmWddRDi8AzNnFrPbbm3Jz3+TlJTzRRouXOK69AmHed/vZ8fSUnTdOp4uK2NoVpZZNzQrFU7kJuBozMPy9XraVEX5f0tDG7SbERG5ECs08G9VfWBLjcNj68ATeP6iuC4yfDjnT5jAPd98QyfXhb32Yna/ftw9bBhdsF3RrtjO3nPA8z4fiwHCYXbChJ5BWORNqSpfYjfaO2ECjYP57cRgvj0FWBj7B8Aox9m4FGIVOTnrBZqagk9VOfdFVIs932Znb+z/U8/5OlhaWM1Inz6R8YHl1dau3LV8fQd2Y76Q+nwiLAf3HKqc9ZtAoy86drN/D2Zm/Q6qI5pwkCOwiKvNYtbp4eHh0VgiJV7nAXMbqmaiyunAO8XFzCkrg+Jiuicl8WlyMicAN2Ila4tDIf4JDC8uZmQoxGnBIBoTo6iKBJb/+Qk77HBg5JgHRIShKpP6F4EE6gq9rx6DYALRbcCnwJkiFDdpwSAyGNvl/R64tdEbAZZSUITqa41q3wxEZC/sune5qj6zuY7j4eGxfZKXxz5YmtDDsbHcQnXK0K7BYI17aWDpUp5wHK5WZSnQLSODTNat+4k2beIIBM7AqsHuyQ8/rOGAA9pRUfE9gcBJIjTol6aKr7KS630+7hchUFDA2oICzuvShU+bbGYtcirmvzkW1TujHtiqa4VQ/b+Gxri5EFsjvAWcChzQKLsHj+2WVhV4ROR/wHHAClXdNfLaQ8DxmOlvLnCBqq4TS32ZhRnpAkxS1cGtNti/EC++yOETJvD4qFH0DoVg111Z1q0b97z8Mgv9fq7AwsnDWOrVCGCMz4eGwwiwN9XmzO2BNap8jEXe9MHKcwcwsceH5bCWAV9jYs8njsOKaOOLCD47Y0LPIVhqV7vI2/OortA1JjubpY09b9clFtu9rRnp0zsyTjAz5CnAFLnl5gz56MOZMmvWC3V2ZhPrQ1ik0L2oftvYcTTqomP9/xtLlfsY1Ucb23/k81VmnU+guqZJn/Xw8PBoQcQ8C0YBZ2kDaaOqjFZl98JCgkVFjAuH2S8zk7zIjm4Z0C8c5rbiYq5VZd7KlfRLTcVJS4NQoRYnhpaFaJOwhuSUjkA/ETb0ShPZCXgCzLsH1bJax/cDTwMXY9UnLxOxsryNXjCI/AOLkPkJuImmmXueDnSM6tWziUQWBr8A5araf3Mdx8PDY/slL48XMJPlvrGxKBYp/w1wfDC4YYT80qWM9Ps5NRxmtiq9O5w5cAgffnQTqamJwGmYcH4cY8asYsCAtjhOHj7f8SL83pixqBKsrOR1v59DKyoIA8fHxspn9bevVY7e7pn/g6URDyaKR1yk/TFAX2BYk+b3FkZEUrG5PIwVbWmdasMeWx2tLfAcBISAV2sIPEcC36pqpYgMA1DVmyICz6dV7Tw2P2+/zS7ffcfTo0czYNkyJCuLwl69GP7gg7ySlcVFmIllGpCD3fC+6vOxDiAcJoCJD1XmzAlAnirvY9Ex+2HmzTHY/wEFkrBJ6HtM7PnQcZjf0DhzcvBhlb2qInwOxqp9ERlblX/P2OzshhX/mrguicAeVHv59MfMkKuYw4bl2qc5Dua7I9IGq+TSliimy7URkXr/CNdfdESux/KGvwLub3IamEhn7N/vDVT/aNJnPTw8PFqQSFrTQcAOWktQqYkqXYH55eXMKC6mW1ER/sREJqWkcAhwH2YevyIU4iNVLszP5w+gV2YmFBVRkpSoPn6cPJt99t0dOEWED+oZ0DFYiP0E4Laq+VWVBGxH9HjgXuD2mn4QjZy7zwQuB6YDNzS4UNh4bIdiUZv3bc6Fg4hcAzyOmXRO31zH8fDw2D6JGC7PxuwKDo2N5WpsThkcDPJszbaLFiF+P+P9fga4Lj906OQfxq677sUvv5yCZQacgq0lLmXChDXsvnscSUmViJwpQt0VY+ugspLjfD6eFmGHV155RYcOvUFWr15du1ltQb4DlrmgmOi/ssEDieyCWVy8QGPNmzcTIrI/Vun4beBc9VJ1/pK0eopWNOFGRE4GTlPVQZ7As+X45hsyvvySEV9/zUl//IGTkUFF37682bs3N911F0cCV2CVT4qB14ERPh/rS3uHwyRi0SLnYqKPA/yiyntY1azDsKigWEzsKQPSIx//lYjYA0yP6osTIScHB1POqyJ8DgQSI2/PoDrCZ1x2Nk32F3Bd2sqDD1yv2dl9OOlkFxN9OlWdLjCTqkifd9/5Uy74x5VSWppPI02XG9wFFrkCOINai48mYUaaNwFf1mkS5+Hh4dEKiEgQS7V9XFWHRmuryp2q3B4KUVFczLTKSvbJzGSuCBWYp1qX8nJuKi/nwfJyvl23jsM6dgS/HxVB/H5eBs7n118/lL59Tm5gYDdgQs7zqL6uSjpWwn1f4GoRNvIva8TcfRJwDVaYYEjt6KBGIdIXW+g8iepGK5OWQkTSgSXA06p67eY6joeHx/ZLXh6DsQ3gc2JjeRsYDeyPVdWaU7Pt4sX4HIffHIdeunTp+Iw+mWN09JfPc8QRn2LR9GdgUfb3MHVqPh07lhIMto9seD7RkPlyFarEA7e6rvuvdevW+W68cSgvv/xyzSbVKbVWkeoZ7B7/BlRnNOrEqw3xv0L1+0Z9ZjMiIrcBdwP/UNVXt/R4PFqfrU3g+QR4W1Vfi7Sbid0YFQC3aiNMED1ajp9+Iv7zzxk2diwXT5lCfFIS4T335GtVLv/4Y9piu5LnYGlXE7H0rZE+X8TfAAiH6YBN0udi6VwKjImIPSVYyt4xmDFzIZbK1QErxT6farHnB8ehUbuXOTkEsAicqgifAZH+w8A0qiN8JmRn1+8FtAEixwG9UH0IwHXpyIZRPv2pEqnC4Qpm/V7CwoXzOOpvj+PzTQFy6ht/VB8Hc8U/DxOQ/rVJO7giNwKzUf242X14eHh4bAJihvUPANmqOru+dqo4wDzXpTwUokcoxNo2bZiXmsqe2A34YFVmFxVREDFWTklOJjYtDUIhKhITmQT05c9Fa+jT50ZZs+bdBga2vlqKXnzxYzz3/EPYTvIgEUbWcy7R5u5PMY+gBcBVqJY08NXUN65Wi74UkbextOrMaJFVHh4eHnURMVyeDGQCO8fGkoxttP4BDAgG2aCM+OLFxDgO8x2HTGfsNz+lnXH4iRrWEqzK4J5YVkAC4fCL5OaWAHn07Nkbi7C5KiL2NwpVdpk9O+ernXfO7jhu3DiuuOJyd9asWc/UEHdq+lw+2uR7ZatWu7ZeM+ZWROx69i32He6hqnMa+IjHdsZWI/CIyC3YgvkUVVUxFTVRVVeLyJ7YIn8XVS1o1QF74Lo4Tz7J9WPH8q8xY0jz+6FfP6a2acOV77/PbCzn9gqgJ5aO9SLwrM+3YbpVOExPTBA6F0t7KgM+VWUkJuicDByLpXeFgLWYuXIA80f4GPt/8I3jVItIDZGTQywWcVQV4bMvlirmYsJJVYTPD9nZFNfZichhwAHUU/kkUrkriyqxJy/vRNq335GEhKrd3RAm1tQ0cp5fFaEU8ae6oKo74Bm1iJ3BWFTT0CaH9m98DhcA0ujKWx4eHh4tSMRc+Q9gsaoOjNZWlaOAUSUlrAmFWF5eTq+OHcn1+agEMoC2xcU8EA5zcyjEzMpKdomkZpUlJRHCCgRkcvDAR2T8+HmovtWIAbbVAw54hw8+GEBaekXE82FcA+f0GrYIgeq5+z0sfWwJlq7buI2Eug9QVaFlFKqTmt1Pow4lR2I77meq6jub81geHh7bJ3l57I2ZLD/atStDly3jDCxd6M5gkLtqt1+8mBS/L5wnjqTIH7OHtx+QfbUqyZhIfgBwAa67nMrKT1i7NsyyZRPo2/cw7L79NBEa9pU08canYdVhwx4cdckllx6RlpZWgVWlvV+EUkTOB84HPkX14SafuMjxmH3EsK2hmInY5sCvmFfp/qraYCUyj+2HrULgETMgHAwcpqp1LrBFZCwwVFV/aoVhetSB6yIvv8wZY8fy4KhRZJWWQt++zM/I4F/nnMPIk0/mUEzoORETbD7HonpG+3zV0SsRc+b+2E3xWdjN+jrgXVXeBZIxk7XjsFSrECbwBKkWf77Aons+dxyaZCKWk0MCFjJaVaGrPxZmX45dlKoifCZnZ2O7mCIHYOlmDzQqzF5ENBB4hN377B++5dYxnHBiYuQ4fbHUNIDVmJfPTzk5ObOPOOLQV5cuXXqVqj7VIqH9G4/pBGDnqigkDw8Pj9ZETCj/GvMFiLrLqcq7qhxZUEByKMTShARCbdvSE3gXOD0c5ofiYrJdl2WrV9M7MxN8PtRxEMdhNHAUcJz4pAPgovpKQ+NT5SBc91PWrInh7LM/l2+/ObMhYV1EemDebOep6v9h/gd3YpsdV6K6thFfTdQDYOm1M1Ct1yS0JYjs+s4HflfVv23OY3l4eGy/5OXxPLZp2bdrV35btozXsPv9/YNBfqzdftlPi7pKMDhHYvyBcFguCQZ5QZU22Kbu4cBgVq+eht8/FpEAs2e/Tf/+p2MmyMeJUG80KAAi12H3+0MEzmjfvv0DCxcuejM2NvZsYC4vPP+UXHrp8cDvwDXNtELYDatg9SyqjS74sjmJWJ+8Dzysqjdu6fF4tB5bXOARkb8BjwIDtYaRlYhEKjKpKyI7At8Bu6lXAWir4K23OGDsWIZ/8QV916yBnj1Z3a0bD3z5Jf/NzycTuAS4FEu3mo+F1P/P59vQ9Dgcxo9N3oOwCJ422IT9ZkTs2QETe07AhJ8QtiuaAaQCFZhL/4fAR47DsqaeS04OSVhIZlWETz9MoCrBDKDHpL71zOKMYdd395WWPEJjXemrTZdTsRD9ea5LDKbw1yzXvisRH4fCwsL8pHXrfpf33u3AjBlz9PgTLnROPXlJU8+pnvHsjxldD2t2uoCHh4dHMxGRt7A5KFNV643CVKU9sLi8nOWFhcSUlpLRsSMLIhsFnYDYUIi3VDlj7VpKk5Jo07YtFBWhbdowFpvHHxThZkTOAZJQfba+40WOeTLwJrCA449/TD779GzMT+G+Bs6pG7ZDeoFaKsL9mNfclY0y52wMIpcAZbSCl4KIVJWDz1LVhZv7eB4eHtsfeXm0wzYopwOHxMaSEvm5FNgjGGQjf8qSY08dVvDiuzeIz+cLhzkxGOQTVeKAkVh0/3X88MOXdO06kfbtE/n992fp2/c0LCL/dBG+qnMwdi/+FnZdeD8NvltrKV47hsPanfLy54mJyeKrr/JYufIQGXROg8Ve6jlOMnA9MBrVic3qYzMgIk9jQRRhrEqwRZpWpaZ5bJe0dhWtN6kucb0cuAO4GYtoqDIPnKSqg0XkVMwgqhL7z3iHqn7SaoP1aBRffkn30aN5ZvRoDsvLQzp1orh3b56fPp2b//gDFzOHvAIYiKVkvYNF9Uz2+TY0SAuHaYNF/wzCdl8d7ILwesSzpxcm9pyEVc0qAvKwyl5BzN9nEhbZ84HjMLc555STQ1uswktVhM9uAFJeVk7Y/U7jEkZjET6/ZGc34Atk4uRwLELpkrpMl12XhNzcufsNH/7k11eedPKcHt127ESXLgk1msxjw9SuqY5DqMknZuWAzwFeRHVRkz/v4eHh0UwimzaLgRENmfiqcj3wSGEhFBayKC6OQFoaQWzePdR1GV1SwpFlZcwtLaVnZqb57iQlsRgT/38GDhWhEruX6BStzLgqg4GngB+x3eDVWNr4EZi58XtRzqsLkDcIbnvN0gmKsR3gxU34eqJj59AZ1f+2WJ/1HkqysE2ZO1T17s19PA8Pj+2TvDwuwzZ3B3XtyhvLlnEwNoc/Gwxy+UYfEDmvcPDQXUvueugGQMNhBgSDTFIlBngDi475N3fc8R5nnPEDvXqlM3/+cLp3H4iZMl8jwog6+j0Js2kIABUfQPxZMKQc9lX4TRMTX2TYsD0ZfHlXRIqwlNgXRWh6mpXIEGB5o1KCWwkReQa4rI63nvJEnu2XVo/g8dg+mTyZtM8+4/Gvv+bMGTMItG1LZZ8+fLh0KVf+9BMrwmF2wUyZz8PKo0/DhJ43fL6NfW/CYTIwc+ZBmGeOAuMwsecjLPLlNCzqpy12U52LRQDtGOnmNyyy5wOsnHmz/rPn5NA+7refTvMV5l9YvOeAtsTEdo+8tS4ypjHAt9nZ1O22b2Vub42c81BUFRE/VuZ3BfCyQGg/KH0J5u4MU8K333Gz3n5nD6qjfPoDXaq+HmAWG4o+0x2H6GlcImlY2tdHqE5rznfh4eHh0RzEqlQ9DOyqqjPra6eKADNdl7T8fNqWlBATDLIoYlLfWZVwURG/RYyV0zp2BBHUcXAdh4XY9aWvCEsiBz4O6I3qf2ofq7ycDL+fq0S4DfgMOFMksrMsEsCqwXShZjUVkTjgLmwn9EGB+J1g0acwvacZKl+Dal5LfGfrETkY2yS5D9XKBlq3wOHka8xgurtuBV4SHh4e2x4Rw+VJWCT+zl27UrBsGQ8DNwDHBoN8vsEHRI4FdluyqHKeP8Z5GygPh9ktGOQPVfzAK9gm5T0cPPB17rp7LAMHBlm16kXateuA2To8BVwrEjFzNsH6fOA7VL9BpPcMuOYxuOwLOHWpVd3tA9yrYV0CPItt8H4PXCZCvdeqOhE5EcgG/tOsNK/NQIPVHj22SzyBx6NFmTeP2P9n77zDqyizP/45M+mFSAkEEIN0FRRBBBEFO+7aV2zYUVYWFbv+dBVsa13FgmJBsFNkKWIDC0WwgYUOihIUCQk1IeUmd+b8/jgTCCGBBCmW+TzPPBfnTnln4n3nne97zvf873/c/fHH9J8xg5TERPTQQ5nheVz14Ycs8n1SMdGmP5aatBEYDgx1nMpzaH2fFlin3htohXnlTMLEng+wWdNemNhTFxN7lmJhm22wgfgKtog9n7ouNRskizTABKrRixfperZU6DoWE5S+a9OG9tvZvx9wLjAS1aGInIuZTR8D/F8RzJoGs9NhQUc4FtWciofwPBqwbeWu9ODrUuBu16XqdAIzOL0D+BzVykNZQ0JCQnYxYj4yi4C1qnrk9rZV5QhgVlERJRs2sDoujrS6dakFfAu0j0R4v7SUnvn55CUmUmuffaCwEJKS+Bo4FDhRhA/Lnfx44AhU7y1/npISDgU+dRySXJeXsMH81s8F6/efx6KI+6C6PhjAX4H13fe+CFPrw+dtYF4rOAvVakeOqtIZe9m5UmQ7XnIiBwNnAUN2WdrXdhCR87EZ8+NV9aPdfb6QkJA/J1lZdMKqaj2emcmN2dnEY5OS9YF2GRls6c9EjsCi9x/+daVeERPDE6oUqNI8I4PVQWXF57Cqgo9SP/0NnnxqPOedtx9FRWNJTMzCUqQ+BM4RR/Kw1KRYrO8sBXhF5Lgf4MOz4fOD7X3idVSfh80TDJdgkxFpwCPAfSJVFGCpiEh7LMvgmcrG8XsDEanyRV9VZU+2JWTP4eztBoT8uWjWjMhNN3Hb22+T9thjXH3sseR+9RVHz57Nwh49mH/qqRzuOAwFDsaU83cxsWex7zPF9zkz8OXZjOPwg+NwDybWdMJmVY8ExoqwUoReIrwONMT8fF7BSjQeiKWFzQFysRDFT4Bsz2O453Ga55FYzUsr84tIbNOGVW3a8EabNlzZpg3NgUzMc2h7DA3acQ4iZ2FC1VwsXLVxItxfBNrHPB8qfSi4Lqtdl3dcl0Guy98xf6OmmLj1GFalq2psJnYdZeXcQ0JCQvYMRwGtMU+yHXGFKpHiYuJ8nyZpaWwCfgHaq7KptJTDo1FWqVIrLQ3y8vCTkliCeafds5W4Y0QAN4iaBKCkhOOxdKwkEZ4DrthG3AFQXY2Vza0FPIBIJmaU/x4W8ZPRG+6PAW6D8dUVd1Tposp72Oz2McBBO9ilLIV9T/Xd47AI1T576HwhISF/QjIz+Qp4ERiQlUXbjAwi2ORmbeD57GzKCwyb+7lGjXjS83hAhGQR5q9eTbIIHubtOQS4iZzcPlx5xUU88sgPJCb+g2j0MOx9ojvwmfbrdw42CfpOebP8S2BWDtDEnkmbsElmwKJBRRiBvW+8htmIzFeluqbzZdGbTat7j/YAVVlJbN9iIuQPTSjwhOwWXBf/yisZMnIkDZ55hjPOPpvvly7loOnT+bBzZ345/XQuTUtjpuNwARYC/2+ss/0fsNz3udP3aVj+mI6DOg6zHYfrsJDPk7DS6ecBn4jwowgnivAsJvAcA7yEmXJ2xNK8vgQWY9E+E4A1nsdYz+NCz6P2di6pzJR4G0GoTRtWtGnDV9u9IRYqdxcmNN0DJGApWk8Gbcm4A0q/o/rl310XdV2yXJe3XJfbXJf3qrHbGswDKyQkJGRP0ReL1txu6W1VUlU5NxolUlJCTkICkZgYGmERihQX860qaXl5NKxXD0pK0JQUCrDB9EeYGFORsj41AaCkhAuwUuAxrsudrstVIttJ37XKncMxD7gngusYhj2zjomFpo8D49i6gEAV11cm7HyGRWPeCuwvwqwd7FpWXKLOjs6xKwgMsF8HzhKR7T0XQ0JCQnbE7Vi/OSQrC8nIYC4WTX4Glj5VxlZCdsOG3O55vCxCPWDB6tXEBL4412ARNv3J33QxgwbewrXXLAS6odoPOB/fT+fRR4fpwEGC6vflG9MDXjwTmAG174eeg+DdICV3MyKsEeF+lNGLAAAgAElEQVQy7D2iBHhPlZGqW7+XVMIGIA+b+P29MLSG60P+BIQCT8hu57zzmPDii7QaNozD+vThy3XraDx1Ki9lZrL+1FO5My2NtY7D/Viq0xnAAkwEWeH7jPJ9ugel1TfjOEQdh8mOw8VYJMv5wHdYeOZ3InwrQhcRHsbEoKOxUPt9seifRGz29DOsZPqrQI7nMcXz+Jfn0bjCZZRianfCTt8IM1h+GzMVPxh7AFyDVQWb2h1Iq0RA2sWsAepg5XBDQkJCditi3l9nA6+r6o7C3M8VIbm4mFrRKHXS0tgIZAP7+z5rolGOjEQoTEuD2FjwPMRx2IQJIL2DGd6KlHmTxZeUcDPwugjiulzuutxXzct4I2jHIdgAPgUTk9YVw+QOQAerllgp2xF2HhaphmG+VT0sZM9GXw7DnlUX7MFzhoSE/MnIzGQNFglzNFv6k8eAqcCT2dmbfTM3YB6Tm4Xshg251PP4wHHIBL7KzUUCQf4W7D2hDwWFZ/PSS49z7jnziERaofoEDz80jLz8fO6663ZV+pYdr4nI8/3hghICzwVwFI4faCLPNn40IkzF+v2B2GTsW9u9WJvMXQ5kYqnJe53ASHkIWyJ2fEKD5T89ocATssc4+WTmDB5M55EjyRwwgEnx8aROnco96enkn3IKL2Rmkug4THAcTsJSmJ7EqphMBeb7Pv19n1oVj+s4FDoOIx2HU7A0rf5APvAAkCXCxyK0EWEQ0AQTeIZgkT3HYYPmWcBkbCZ4CPCL5/GF53Gb59Em6LSL+C0CjFVbaQ6MCNr5GRamem1XqFsP4s6FAUkiURF5eqfPs33WYL/7cFY2JCRktxL0Y7mYUPDPavRrV/g++UVFFMTH48TEUB+IUYXCQtYBBdEoqWlpkJ8PSUksxwT+80RYXcUxIypC6a+5DwIPixB1Xf7mulvC8qtBK8zX7XvMC24o9ty4uxUklQDHw90NK/Tdv1nY2Zq17KEIHgA1I/5c4GkRUdm9z6WQkJA/N8Mw751Hs7JIy8jAx7xufOCV7GxcVD1M5NlKyI5GOTka5RvHob3v8xJsTqUaiEUHXcCmgpOZMmUkxx83l7y8NAZcdy2ffPIQIlOA51QZrE89FfdvuKI2ps7/ivkkTATE/DTPq0LkiYhwD1ZRtzqiSBY2CfC7sUMIxJxYbKLi9VDc+fMTCjwhe5yOHVlx332cOmoUte+4gxf23x+mTeOKaJQNPXvydufO7Oc4fO843IiJMJdhs5dPA7/6Ps/6PgdXdmzHYY3j8Izj0BUTU+7EXgCeB7JFGCtCIxFuxyJoumBh942Av2ECz6eYB0EcJhIt8jwWee++f7w/4Lq2nrcTvxuROCw6aSOwGotWSgNavwbD8uDCkZjr3EXgJkD/3TSYLksjCNO0QkJCdhtB/9WfLeMMl+30a6q0BTpHIqSUlhKTlsZ6gpRSz2Ml0Co/n+S6daG4GFJSWIv113eIML2qdmhaWiQ666teWrfeFSIUuS6dHYf3a3AhKcBpmA/Qs5hfzt+BdYfCZavgkhFYDP/F4DaA/r169XpLlffZIuzcws4LO2XsUf+04O+UXm7Vdv9+ISEhIVWRmYmHPQ8aAIMAMjJYEaw7EusjoRIhu0kT1PM43Pd523G4NDeXm8q+E+EB4DrgLDbmdWP+/Ol06LCWNWuKOPfcB7Do/MHAAI47ft6BtWrJC7CVp8K3wER7TrUAzq1M5AnOtVSE6lSgLfPh+T2laaE2Uf0V9kwK+ZMTVtEK2et4HrHPP8/tU6Zww0cfUct1oX17vvB9/jV16hbjYN+nE/AvzHMnARNingH+5zhVlwgP0rs6YDOv5wMZmNAyFvMZmKaKj/n0nI2ZFjfDwhlnASuBxvj+kTiOE/z3+GCZ5rqUsiOsVO8J2MMtA5s8qA8s+RD6xYD8gJUayMBqp78KXuGuLmFoJX5vw8ycZ+7SY4eEhIQE1LQ0qyqPq3LtunWgilPPJOgCVZILCsgrLcV1XZJTU6G4GC8xER+YApwa+DJsQ0kJcUSKpxGf0MXxoxuduJj2jsPymlwE9sw4AIvePAyL5mkIrP4E6s8FGYPlFQ/s0oWedw2kdc+eYOLUw8Czv0HUKd+Wo7FZ5vvLG4buLsLSuiEhIbuarCyGYlUID83MZF5gsjwSqxLYOaOhNMCqIT5Qscx4bi4uli57DnBpejovl30XpGENZdWqb2nT2ichIcq8+UnUr98OuJkxo1ty5llX5i5dKkecdio//vhjxaZ5Cp2BU4ElwOggoqjm2HPjRuBHVP+3U8fYTYjIncDdQJqq5u/t9oTsPsIInpC9jutS2q8fd48Zwz7PPEOfU0/l13nz6DxnDnO6dmXpSSdxemoq4jh85Thchvno3IQNst/AvHru9332q+z4gTnzHMfhhmDfEzFx5hzMmDMrmFmNivB/mIrfAXgI01vOA44kO/t7vvn6cyyq83Ls5SLH83jV8zjL80iu9AJFWmEVvLphUTtDgd6oHo9q/3NBRmEhNb2xJOW/A1dZ5Zdd68lj5pmbCCN4QkJCdi9V+Xxts16VeFUuikaJRiIU16pFHhaqn1xaykpVUkpLSa5Vy1KzEhPJx0LNL96OuJMCfEN8Qhcnb/1Gp9dZZ9RI3DE6YAP+HsG/JwM9sefOP94FaQE82aULC959jwGzPqNxx468c8vN0Lv34SI8skvEHWOPGi1Tg79fSEhISDW5g60NlxWzw8kBXos2a7kJi55PqbhjejoecDFWBn1Ybi6nlH0nwvN8//0AGjRoz5KlScAymu2fy8qVHwGPECk5mT593k3KzIx8/vkXHHXUURUPPxTVOVh1xNZAr532qjRhKgto+nvx4SnHbECwCe2QPzGhwBPyu8F10d69eenll2k8fDgnXnwxC1eupOWsWYxv3pzsnj3pn5qK6zisdRz+i82k9sTMkm8DfvJ9Jvg+J/l+5f9vOw6e4zDFcbiUwLsBKy9+HfANME+E20RY57rcgXX0BwP3k5yczKEdugTnnIOV/P0Q02PGYhW5Jngel3peEEovcigWJdQaC9e/HNWR5Wcm1oE3FPgH8AhsNpXob1W/xiLSadfc4c2ElbRCQkJ2NzUpzXq6CHWLioiLiyMpLo5aQLIqGonQqLgY6tSBoiJITWUdNvg/R2Rz1ZWtKCmhHlYt8UAHb557QOshzqS3q12hEACRdlhacHtssH4jqv9BdS6qvVGdOfOII7zYd9/j0FmfUbtjR5bdcjNf7d8U59FHVd5840pE6tfonNtnT5dKD0vrhoSE7FIyM1mLjdePwuY0ychgHVZN64B146b1CTatVMhOTyeCRft8A4zJzaUbACKOtG5VzEMPvk6DBi35+ZfW1KqVR+Z+Pq+8ksWFFzZh6FA/OTm5Y2lp6YYpUz7ksssuA+vPthgOq34FvIuVST/7NxQkyQJqsR3z/b3E7OAzTNP6s6Oq4RIuv9tl1ixte+utOv3AA9VPSVFt2VLzTzpJH0pJ0cTy23meZnqe3u95muN5qp6nP3ie3uh5Wqc65/E8red52s/z9NNgf/U8ne55+s/Nx4Ce/t9PeTwa1YHRqM6LRlWDZVY0qkOiUR0ejerP0ahqtNSPRn/4cal32+0r/WbNlilcrkFKZMUFe4nQ8stBoBPhO4XvFZYqjFA4VcH9zfcVTlG4tar2hEu4hEu4/Nalsn4tWJ6uuK3n6eRoVCMrV2pRcbEWeJ5u8n3VggJds2GDRvLyrK8tKNAS31f1fb2+qvNGItosEtENkYhqaalO8d99L05hkEKParUdXIUrFOYHfe+1Fftd39cjfF8/8H3V7OzVeuONN2pSUpJ2AX0UdBGsDPruGQqn7ZK+FuKD6+j2e/v7hUu4hEu4VHdZvlyd5cv1i+XLNXv5ck0rW79qlT6xapXqpsuvfkWhw/aOkZOj6Tk5uiQnR9fn5Gg7hcOC/vFg39fTfc+P+Kuyf/br11+tUOT/5z8LfV/VLyj8wve16aJFi5f6vmphYdHjvq/bjquhc3C8c3Zq3A31g/3b7+37XXHB5pFH7e12hMtu/jvv7QaES7hUZ1m4UBvee6+O6dpVoykpqvvuqyUnnqivNmumdctv53ka73l6vufpjECkKfI8He552qm65/I83d/z9A7P04XBMUo8Tyd4o0YP9GvXvq+ss49GtU00qv+ORvXbcmLP59EffnotOnrskujSH4rKrZ8TbHtQNKrbDPYrDKajmwfR0EFhvMI3CtODf/dTqLsz9zE4ZpfgwZO8t/+u4RIu4fLnXYCPK+3Xyi2+r009T/1Nm1RXr1YNBBwvGtXSvDzVNWts3YYNqr6vUd/Xcb6/bR+qqkQi2iES0aJIRDUa1Zc3bwe3K5y0wzZDO4VXFL5V+Erh+Apt7Vom7Pi+5vi+3lS7du0Xt7lG2FfhToWFCssUxilc9Jv7XLhJ4fQ9+Pd7YUd/v3AJl3AJl5ouy5frYcuXq798uQ4uW7dqlSau+tVfmL10Y16kQ+ezdnSMnBzNzMnRlTnZ3qqSw498SOESBVE4zL/0ssl+UbHnL1pc4mc09BWy/L59F/jFEd9f8fOG8e3bTxjx5JNlz5u3fV9TtzkHHBGMlXspODW6RmvHrQpn7O17XXEBxgDL9nY7wmX3LqHJcsgfiuxskseM4T/vv8+V06eTmJCAHnwwH23YQP85c1haftug0lY/4CIgGQtNfAYY6TgU7ehcgTlzeyyM9AKgIcXFJYiMJj5+BDDVcSxc3fNoSXHxuaxb908aNdoXgB9+WMPKX+bQ7ai5uO5RWMUugB+wKl3jgC9c1zwkRGQZMEtVL9qqISLNg/M3wIw+mwOlwJfAKFTn1uAWgkgL4EJgOKpZO9o8JCQkZGcQkRuA/2KGjnmVbaPK3arclZtLNC0NPy4OH0goKqIoEiG+Vi2cSAQSEykSIRvoIMKGiscpKeEkYBIQ47r8J0ixLWvIjcD3qE6soqGJwLWYP5tifhBvERhkqtIVGBh8n8sW8+QCEUkCCoBbVfXhCsdtiHm5tQWKgDxgOvAmqst3eAO3beflgKJakxLvO42INMaqh/VV1Rf2xDlDQkL+GmRl8SzQFzNcnguQnU0HfO8r96dlX3jNWx0ZePRUSW4uB1ES+Vzy8yIp/77+zISxr/8dG2vn68CBX3PnXTeRne3x9NN/kwcfWKPXDriK++7r5xUWOt+cdGLMQWecOS/xzjsPIhJZhuOcKAnxy7c6gUhXrN+fB4xDtVLPt0oROQ9ogOoT1b8rux8RuRV4EKinqpWmOYf88Qk9eEL+UGRkUHDNNQyYOJFaTz/NrSecwPqvv+b4ZctY0q0b33TrxmbnNMdhruPQDyuBfjWQBLwErPR9/uv7tNzeuQJz5m8ch5uAJrw15kpmz15IbOwZmPfOiuA4hzoJsWluSmI7d7/Gy5xuXYcyftxY4uMidO9xEq57MxCPdagDgZ+A6wkqdHkeQz2Pk+Li4nwq+02qLsNMPbMxkeqGYN9OwJOIDEPkNERiq3kby0ql77GSuyEhIX9JyowyCyr7UhVXlT7RKCpCTHw8cSIk+D4lnkdCfDyOCDgOJSK4QK/KxJ3SUi4B3gNc1+VfW4k7RjFWeXFbRI4BXgNOxgoZTsZKyb6rSldVJgMzscouN2Plzh8V2XxNVZtoqq7C+us3MN+2n4DjgZcQeQqR7jU04VzLnu23k4LPwj14zpCQkL8GdwDrCQyXATIy+Dpu2pTRXvNWRxB49GyP9PpSmHrdFWM1NS2t8MY7J/m163TGjJIvkEGDBuI4J9CokfKf/7yqvkbkicHXkZLSoSQxMe+gadMpWrJ4E+eeM5dodH+KihbrlVcOQaTj5n5ZdRY23m8HnIFITd6bs4DaiNSq0V3Z/ZRViQ99eP7EhAJPyB8S1yV6ySU8/Oqr1BsxggvOO4+sH3+k/XffMf2ww1h+zDGcn5pqDwzHIc9xGILNovbAql9dCyz1fT7wfU73fbZb9tVx8Jxzz5nmdD9qghx7zKFYBa6vUL0G+FoXL53mP/FkO+194Qvy+WcvumefNd/dP/MfwP5Yxa8IZix3NxaJ8zD2svApFk3z/urVa5oNHz6ifaUNMJHnTWxw3xmbFT4XM3DeB3uJeAuR/oik7+D2bcTC7UOj5ZCQkN1JClCkVZebPUGExgUFSK1aeKqUqkJxMXG+jyQlwaZNaEICccB1IsypeIDSUm5XZQTguy5nui7PVnKeCCayb0EkHZGHMNHdB/6NCeeJOnFilvo6ERN2DsH68IrCDgALFy5p/9RTQ2jUqFFcpVeougYYAawAfgQGYJFG+2PPg5GIXIxI5VUYt2YtkIJI/A633DWUCTw7jHgNCQkJqQmZmazDxsXdsHEwALX7/ONld8VPK1Adkp1deXVcAERigNsS3nrt0NRrLl3s7d8ide03K+Jyc/RJghLgIswCjsMq2M5QpZUICy667NK+3y9fTtbNt/woY8f2pM/lt1NcXMzTQ/rptQNeA8Yjcici3bACKR9jBVdOr4HIs7zsUmtyX/YAZc/RUOD5ExOmaIX8aZg+naMmTuTJCRNon50N++3HuoYNefiLL3gsP5/S8tv6Pg2BK7Dy5Y2Bn4HngBcdh9WVnkBk32CfN1BdisiR2rDhLVx8SRu9vE8CLVrYg+inn7L4/PNpnHrqDU6tlM3hj55HE8z9vxdwZLB6AVayfdXIkW/en5OTs/z66wdULvJYG5ph6VprgVdQLQhc/k8AzsCc/0uxSJ+RqH5XxXH6ARtRfaPKc4WEhIT8BkTkGeBsVa20mpTvM1aVM9euhfR0RBWiUUqKi4lNSkKKiyEpCRVhFHCByNbh+qWlPKNKPxEijkMP1+XzKhpyERCP6ovBzOw5wCVYOd53sNTdTL3kklt54MH2ZGR0wNK0HgaGVhR1PI8U4Hzs+dGxsLCQ2267ZeiQIU/3287NSA/OCSb45AOnY2XYm2AiygwsfeunKo5xYND254LooN2KiHTBXm5OVtX3d/f5QkJC/lpkZeFgfUxToHVmJhsQ6VhyWNeL1k38tA8is4HjMjLYOjXKqhw+gE3czgUeyc3RpsArwFvAeUFZdQBUORiLxPGB4x1HYpOTk78uLi4+IxqNTgi2qUNJyXji4o5i9OjZXHD+BvH9WCwC9RtgHVAbG19PZEcv0CYE3QrMR/Xt33KfdjUisgRYpKpn7O22hOwewgiekD8NRx/NjEcf5dCxY2lz4418mJBA7S++4MF69dh4/PE81aQJqWXbOg6rHId7sYfKWcAS4D7gZ9/nTd/nqMCDpzxls5j1EBkE3C+rVkXloQevcFq1yCQvrxmTJo0lKSmR88+/mJSUbN9nou9zru+T5Lr87Lo84bp0A/YFrsGEmtuBpzt16pQ4Y8b0ddu9SNUfsXD/uoDN+qp6qL6P6lXAVdiscwfgCUReQuSMStK3wlLpISEhu5sUYFNlX6hSHzi9uBhJTQVVG8BHIsTFxlrfGxNDqQjfA33LizslJTilpYwPxJ1816VtleKOYSlaJpA/h3mzrQauRfVx/fGnbrp4ydsMH3E5DRrsi0XsNBPhv+XFHc/jEM/jGeBX4Hkg3fe9BfHxceTl5UW2eydUc4GXsZSuS4AUVEcDFwO3APOxmeZhQfrWMZWkb+3pUulhBE9ISMhuIzMTH/gXkI5FNAKsi5s9a0PMonn3YlH3N2zewSIv7wGGAC2BicCZqM5IT+fVYNuzgSG5uVvG8CLMBY7GyqJPffnll/ctKCjA87xa5bZZR1zcccBznHPOYRQVF2nz5kOAhVi0y2nASVh/fc8Ooy7Nr2cFv78IHrA0rTCC509MKPCE/Ok4+GCWDBrECRMnUv/uu3mteXNivviCq6NR1h93HGNbtqRR2baOQ9RxGOc4nIBFvwzBvBimA9/5Plf5/mZhqAjLCZ6CdfRzsIfJfERSndppmc7ppy6UzCYnYn4NgzGhZSSw2vcZ4fuc4Pu4rstK1+Vp16U75hH0r5yc3NIVK1aU7PACt4g8dYBLtnrIqC5GdRA2y/saFpZ6HTAWkavLpW+twXKDt5uaFhISEvIbqFLgAS4SwS0uRhMSEBGckhJ8EUhIgIICND4eH/PdyS/bqaSEWGCWKqeLsNp1ae44/LCDdjTB+uwXgWaY0NJHfa2tvk6hadMPadSoMb/+OgiRrYQdzyPJ87jU8/gM+BboA6wENoiwn4jUfeyx//L999/nV3HuLZjIMwIbe12KSN2g5MWXqN6MpSm8jaVvDcTSt8r38WUTAHV2eK5dQ2LwGXrwhISE7BYyM5kDDAWuzsriEAIhu+5JHT/BipHcv3pBbgdE+gKvYhHwq7Gx9R2USwFOT+dxLLLnn8Cg8ucRYTEm8hRccEHvl5KTkwFqVdimFJsAuJbY2L/z/Q93qK9PYdGW92EebS5WvOVTRJ5ApBcitau4vOXYpHBKFd/vLWYDjcUKAYT8CQlTtEL+9HgeScOHM/D99+k/eTLJMTFo27bM3LiR/t99xzYVqHyfZOA8oD8m1OQDrzD48Q+cG28Yh3XuecCTsDkENBnoiA3A52MeN1GNi/O4ql+mnn9BBw455FDi4xMoLNzId9/Nkjden85zQ78Xz4sC0bPg6Tj4ZaR5QZSWHaOKpRQThs4IzvlK0KboVmGjNgN8AnAmcECw72ws3PQAYEjw0hESEhKySxGRyUCKqnYtv94qePJDNEozz4P4eBSQggJISoLCQkhOBhH6iPBS2X4lJSRjfVdLx2GJ49DRcSo3cK7QkFwstP5HYIJeemldbrm1O23aNCMvr4ghQ1bw6CNTZP36RQT9q3/e+fV1wHU9OKT9UcTFJRMp3ohqqSQm1sP3S8nOnsHMmRMWXtX3m3M3bJi+Hzz8nkUHlfXP236WvYiI1MeieHxgBBUrmZjHzmlY+tZ+WASSpW9Zn/8TquOq/5fYOUSkFzAaaKeq83f3+UJCQv6aZGVRB1gKLE4bPOiofQbffTswe/WyTV+r6y5xV69y6vVoO1eKCpdgEfc9geGYn1le+XFvELnzAibGX5OeztPlz6VKZv/+/Z999tlnTg5WecBQVb26wnY9gVHY5O4ZIkGUqNkiXIP10UlY/+wB32MR9JNRXR1sW2btMAbVBbviXu0KRORIzAP0NP2dpY+F7BpCgSfkL4Pn4Y4fz7/efZc7J04kvbgYDjyQRSLc8PnnbOMvEKRoHY6Fj54LxPPZZ0Xy1JMO48ctlkjkc6yDXIoNulOBCdiAPgaIDT5jgBhNT0/Uf995GCeeeCTNWxyC67qsXZvD9Glfj7nzzvTvFi3sGAs4oPvD7Ivh3Wpc1j6Yu38xNrtcij1oKhOIGgCtgIygrS2C/U5DdXbN72hISEhI1YjIZ0C+qp5Yfn1Qdnxmfj5aZoZfXAyOA64LngdxcbwMXFaWmlVSQjomntd3HGa6LscEs63VachGoJYedVSEhx4upEuX2kQiG/jk43Gcf36sbNy4Fpih6fUT9d77uurJJx9H431b4Xs+BQV5kpxcC9d1+OWXX3ln0nfy6KPz5MdlRQAj4JTlJu4jO+67fbYIPgnYfqWYeLORyoWhNsARQH2shHs9TPQ5EdUvq3X9O4mIXIxFOzVXixwNCQkJ2S1kZdEHi7K8JLOpJGN95MFFp/bqtvH50S3iJ731be0re03A0qQOxaLp52D95Nryi9ek6YZ1Xyx9kpjYU4EL0tMZWXYeEXkam8CtyJBKRJ4DsajKxsDlIrxRdhCsIuKR2CRrPFYApR7Wzy/HvIU+wiaMv0W1OmP6PYKIJGGT1/er6l17uz0hu55Q4An5y+F5yMcfc/qkSTwyfjwt1q2D/fdnVVoaA7/9lmH5+RXM3ADfpx6LFt5GrbT+NG6cQH7+JkaO/EWeemKOLFiQj4k4g6ur0Ps+tbE84QuxkFFmzZrF66+/xltjRrNx7VpS4bm1ZtAWU8VSJiDtB/wNM4KbQuUCUyzQMNh2P6wyzL7B+i9R7VzzOxkSEhJSNSIyD/heVc8qv973eQ3oHYlAfDyoQiQCiYmQl4fWqsUS4LCyNKnSUlqo8jWQ6ji85bqcU9FweXvoGWd8wrUDunHMMTFs3FjMkKd/5tFHp8uGDWuBPO/Dj9+jxzEXAJdi/jYbAFeEVCAXS3cd4TjMDQb2LhBbHwZHoW/5zjYWaASvT7dKhxW/qth31wOOwXx5PgNKqtgn1Q5LSyztNwar4nh4de/BziAiVwHPAo10D5g6h4SE/HUJDJdnAfvve0idGHfj+jSs/121/sW39omcfOb+addeMilx7GsxmNhdNjGZHCwpWESNAGhSsrP+3VlHeK0OrJtyW//xia88vwDI7wcP5oMTDQ7Clk9/tE3mlq1SQLVTp1QmTLyFjIyDmDVzNMce+4aUlPjB94diIvxiTGxqFqxrELRHMHFoX+B4VD/d9Xdu5xCRucBKVT15hxuH/OEIBZ6QvzRz5tB53DieHD+ew7OyICODvMaNGTxnDg/k51O81cYi3dR179MXh73DBb2PwXV74vsw+YNCGTF8MePGfSCe9zEwA9Ude+kEZGZmRs899zy3d+8LadeuHaWlpUye/AFvvPGG//rrb6Q6TjX8D0T2x6prbQBeRnVT4OC/H1Zl4ADsARjBInx6YDPCAFeFETwhISG7GhH5CZihqheXrVOlliq5kQhxCQm2rrjYhJ6CAkhOpliEDiIsAigtpYsq04A4x+GJmBiuq+75VemG+TAcx8aNRaSl/ZsbbnhNBj9+lsbHn6//OLudDrjOp+NhdVH18f18iXHTUI0i8g7ml/Ou41Bpfy4iUUzsqYinqtXzNxPJwIyWS7F0rfXB+tpY330QJs4LZtZ5MPbC8Lfd3W+LyPXAY8A+qrpxd54rJCQkJCuLDsDs1Jef9usMvMbF/L9GevUzFqyZsfhmvGhKve5t33Vzs9/BBBYJFoJPhy1iT4rXoGHdDe/M6uXXb1Ar7eIzPo+bOnnD21qRy6QAACAASURBVHCKYHlXhdjMaEHw74E2qVpc7ngAoqmpMXww+Wy6dOnM3LlzOfGEUZKTUxJs0xrrm7OAH4I21MXG3y2wPjwW+BrVjrvnztUcERmGpZnV11AM+NMRCjwhIcDy5ew/ejRPTZjAyXPn4qSlUdKiBa8uXswt2dmBsaXIqcCNQH9UF/gb85vx1pgPOOXUFqSnw88/FzBieLY888xPkrP6O2ARsD5YNpT7zAvc9YPDyuYfYbt27bjggt6cf/4FNGnSBMygdBzwOvCR4xCt8iJEmmIm0IKVX2+OPeRKsZzlBcG/LwC6AFmoVl3WNyQkJOQ3IOZ9M0ZV/1W2zvfpK8JzZaKO523ZXhViY+ldFgZfWsppqvwPcB2Hm2NieLQ651XlKMyk+DhgNQ8/lMNDD0+RdWtv9Dya4ftXsnHjDdSuHUdRkS9xsUJMjPDzz+uYMnm2/PfRubJ4cTZb+u3yS1kfruX77m3boBUrYG3vRmVgnjwCfI29LDQOvv2ZIDUN81M7GLgH1Y+rffydRETuwIxF47UGkxYhISEhO0tWFkPwvX9lnHZ4fvz8r2/GjJCTC8+/PDnvkedvdLJXTq7fcb+e1T1ebi4ZwExU0+LefuvMI68455O64NbFVJi6WC6YgA6Ee7BJ0PVUSPvSunXXsDqnL47zKOYFd5oIK4Oozr9h/fNaLBIzERP/m2ECUGPg1N/TZKqI9AOeAfZX1eV7uTkhu5hQ4AkJKcf69dQeNYqH33mHi6dOJS4xEb9NG95ftYprvv9BjgIuA85FdXXgin+Hpqam6rQZP9Cq1UUkJnagpCTKlMkr5KmnFsuUyfOxiYHyg30f81vYAKzvDv9bB27Zm0QBlt7bvXt3/6OPPnkJ6IVVwyqrGvA6MNtxgqhSe7g0wmZ7uwFdg3OOwUJGv0e1BJF9gL7Y86wzMBzVl3fbzQwJCflLIyJFwFOqekvZOs9jse/TOiaIbykpgbg4yMuDWrV4UYQrAUpL+acqzwLqulzoury5o/NtI+xYmtRzJMSP11tuzdFB96QDJ4Iq0agnsbEx+P4G1qyZKLfe8iuvvhIvJmQsxrrj2sFSi637cA/YcBEMXgdOeQV/PRCpWQRPMnAg1m//HXs+vI+VsV2A6gZEDsKeA62w/vs0VLdfln0XICL3AbcBseEMb0hIyJ4gK4vakrcx212/Jiea2Twzs6nEYCW9/5l37+BuhVcMaBazcG6/escePLS6x8zNpTlmgFzSo8chHy9cOPeS8t8nAS3h5W/hCbboPnWxioXl+/KI3nNvI2699Qp8r4D7779L7rtvI1apsR3mcTkDq7Z1NJaa1Ra4G9VPdu6O7B5E5DDsOdNLVd/a2+0J2bWEAk9ISCV4HgljxnDbO+9w/aRJ1FKFbs1/XfF/Sy9bc+SmyV1QLUWkK3Ai5SpR+T6HotoP1QtxnESWL1/Ju+98JP99dJgsX/4L9rKwT/nPV6DXj9Cp7Nyl2MtCHZhyLwzWzMxCHTa8HZ069SQ5+XhE4lBdyurVE+T/bpsnr7xcJzieh4WHrsfModeyJV0rFqsosA8W1noycBGqP++RGxoSEvKXQkRisO7sLlW9F0CVdsDckhKIjYVoFGJiYNMmSE1lMXCoCMWlpdytyl1Aqetykuuy3YFxIOwMAo6lnLDj+9SjqOgqCgtvpG7dOKBEhDhUlSVLltCs2SDi4iY4DsWBUN4SE4caBMf5GDPRdzCRvXb55WHotxZ6JFZoTyP4rK+ld1XUftZj4n4cljZ7EDbDK5jXxErMv2E9lq61IYju6QNkY2b+P6B6fU3+FjuLiDwGXKmqqXvifCEhISGIxG688qa5G+54pA1waWYmLyNSC7hR4xPyc2cuucavU69+nd5/uznus2njUF1ZncPm5tIemAas7NAhc9Yvv6zoE3xVaRWtoC2C9f3lRZ9meuyxR/Hqa6dRp048AwYskuefW4QZKxdhz4dDgA+wydf9gdNRrV5RgD2EWLXGfOBxVb11b7cnZNcSCjwhIdvB83AnT+aySZO4Z9w4GubnQ4sWLEuK9wbM/CKmKVCM6rCK+/k+++B5l1Bach0JiU0pKCjiyy9mMGvWQ85dd35SoZR5XAt41oXL9gGpDf6hMOUBGI8JMgllm2qTJnX0yr7tOeXU1hxyiHnoLF/+CwvmvyuffDJEHn9sUSA+NcXStTZiLxo9sZeJN7AZ2QRUe++WmxYSEvKXR0TSMHHjBlV9HMDzGCHC5plT37e0LFUisbG0FeGH0lKGqXK5CIWOQ2fXpcry3JUJO6q8oEoP4J/A30Ad9XzmfOPy9tvk3nPjhqfl2GNT5dtvPkD1w8oajvWVx2CD+ZXAR1RRRUpEhiTAv/YB6oDXDsaPtD63vJDvBks9IB2bMC7BRJ0FWLj/suB+1cI8eYqxEr3nYgLTl1i61BBUx2zn1u8yRORZ4CxVbbAnzhcSEhKCSKY6zsu/fLGysZ+ekQa0ymwqHbEI9Sdzvvypod+oyRx3+bKf63U/8E3xvCXAVFR/3dGhc3PpDnzgedG5zZundSosLLxFVR+pRpvqYZE4bQkqZelhh63lvfevom7dtnzzzTAO7zRRPK8uVha9I3AX9hz5GtU7dvJu7FZE5Cus0uWxe7stIbuWUOAJCakGnofknNN/9Ij6t5700of7pd5wvV/at9lH38g7b9/rPPXkpKr2832EkpJj2bDhNurVOxYRhx9/nMevK5/A90c4x/TY7EAhIm9j1Uq2NmET2ReL8OmAzQbEA/na/lDVAQNacvwJ7WjUqAG+pyxatIz33vtSnhg8U3791WHLC0Uz4CngCyx1622Cl66QkJCQXY2INAZ+Afqq6guqxKuy0feJdxwTd1wX8vMhNZVepaWMFeE9VU4SYZ3j0M51qXTArsrRWCpWmbDzoO8zERO1r8L6SW/+fNw3XvdLR40ocrJyk12g5E3O630eo9oCT6K6bjsX4GCzsD2wGdyfgI8rRj2KCUI+cI+qDqxwjFgsreowLHw/BZstXoOJ706wrjylwTYJWOpWEmb8eRJwCtAL1bVVtnsXIiIvA91VtemeOF9ISEgIIl2ABzdcfcebG2+67xlKS5/MbBmXDfyE6miA7Gz+CQyN/Xz6E3XP7L4K87xZSjWEntxczlDVsZ988oFzxRXn3Jifn/dYFe3Yhy2iTgYW/b4c80RbhGqhKvHA85goPwq4TBzpi0ViTgSuBf6D6uTfdE92EyLyDPbcrK3lvEFD/vjscYFHRF7CBik5qto2WFcH+2E0xX4856jq+mDg9ARmXlUIXKqqX+/RBoeElCEyFEhYslgfb7xp8X8T27XsgeMIIqOBR1yX7f6/6a/KbsKatf9mv/3OIzW1Fvn5a1m37kUyM//rOOSKyFiglaq2q1BBpezBsoItD5ZNQZsESPFff6MznQ4/n8aNTyEhoT6lpRHmzZsnr7+6iKef7iTR6L7AzVjaVn/gelS/2T03KiQk5K+OiLTGvGwuUNU3PY+LHYeXyw858vPNd6e0lH4ifKVKexGyAnEnv+IxA2FnEDYrulqVh1RZhqUwnQI4y5bByJHoiBEU/vQTyYLvd+aLjfFEnvqeloNXsu+lwFpUX6nmhcRgs7FHY9VZlmBCz+py1xoFHlTVfyPiYgb3bbHyuXGYWf6CYPm5YgQnFuVTFvFTtjQGLscqaP1fcP4iVPuwhxB7trVV1QP31DlDQkL+4oichQkjV2Ut147pV56RmzRlQldgWJnAnp2NYALK8c7Py7vUP3z/NOAITOgpi+hZVdUpvvpq2Q1Nmzb/74IF33150EGHHJGejh+cOxUT1ttivjpgExXzMU+0yp5Lgo2vH0R1Nh0O/Ui++24GcCT27Dh9T3im7QwicjkwDGijqkv2dntCdh01EngCweVUbKBRFxikqlki0h34XqsRHiciR2ODnVfKCTwPA+tU9UERuQ1TEm8Vkb8B12ACT2fgCVXtXLNLDAnZRYi8RpByANyoJ5yw2n9vcmtsxrgW8CHwCDDFdanyh+U/9ngCzZpfx0EH9aF58xZ4XpRNmyZefPFFdX59Z1Kzj1Xvx2agwSqo2ItBJQ+WbY7t42BhrBdippz7kJdXyKczllC37i1yZNe/i2pz7IEThu+FhITsFkSkIzAbOE1V345GWeI4tBKx6B3fhtM/itBJla9VyRThG9els+OwlVdBBWEnW5UhwaD6KqDRzz+jb72FvPoqJXPnEhfsNgMY+RldSrvwRW/gUqxUbW9gNKoLa3hBcdg45EgsumY+8Amqa12RSBcYPhPew7x1EjAvhoXBdlnUdHbUIqCuBQo0KWmiFBYOBt5A9fkaHec3ICKTgIbbRJWGhISE7C5ErgLOw943NwFXYymrL5Yft2Zn0wDrX38GumQ0FMH66K5YH7wYE3qytz2FZF5zza3L77zzQYgUP1Nv/9SXJBptiwUaCOZ5VibqrK9Os1U5A9XXyMvzGfL01fLvf58HzON37G8jIu2AucCFqvr63m5PyK6j2gKPWETBu9iPJw9IBTqp6tdiL77rVPXaah6rKTCpnMCzBOihqqtEpCEwVVVbi8hzwb/frLhdTS4yJGSXIDIB6/DHYGaXw1HN8jzSsOpU12HCzHfAw8Bo191uWfNY7X/1RXrCCQM49rgDSU6OWTtvrl93ztdvyODHRsi8ebNR3bizzfV94lm//jR++vFu2h/aHMeJk+sGzJOnnhxHxVSCkJCQkF1IMPEzFTjW83S5CD+WDTdEID+faHIyXT2P94E6jsN7rsvfRbaI46p0x1KxjlElGxirSjPgxJwc3LFj4c030VmzNle4mo1VGhytys/Bycq/LJyCVTV5DNVyBdprdGGJ2AtEZ2yiq2AQ3NYKvroAJmEvFfOBH6tzDlXisOfGvlst69e3ZuPGduy7r0tenkq9ukuBK1D9YafavROIyMdYBa2j9tQ5Q0JC/uKI3AV0RbUnFgl6PvAWqtv4sWVnczrmV/lARga3B/snYP3zEZjQswgTejZHXR4gclAszH91+NjvGv39rEPix77+ca1+F44H5mGiTu7ONF1fePE0zj77VVJS4ul19mKZMOEOVN/ZmWPtCYJiCHnA86p63d5uT8iuo3plPI1HsHC1I7GyaiXlvvsQC0/bWRqUiTaByFM/WN8YKJ/v/kuwLhR4QvYsFr2WhHWEh2KpTisAXJeNwCOex5PABdhv4XXgP57HY8Aw16Wg3LHKyuK2lSFPN5EhT0/UeulTF/TufU79yy6vz6WXXqgXX3y6Os4IfJ51HBbtTJMdhwj16rwPHKRHd5+qN938N0aO7IqVigwJCQnZnZRVXtrkedzruibsqFpJ9JQUbvI8pgJJjsOwmBiuKNuxgrCzWpW3gU7r19N//HgYNQo+/tiigByHxVh/O0qVysSPfTBfG8H8cGb+BnFH2FI218eqbTU4EGS5pZE/U16UVyUBG7Psu52lAVuXYAfYREJCDtnZEYqLP+OtMS2B1XtS3AlIhG1T5UJCQkJ2I3WxaHkwkWYjFg25DRkZTMjOZhhwa3Y272Zk8CmqxcA0RL4AugTLAViQwC9Aw3HQbSTwS59zvtn386VrIv/ofVzumeePTG/gTP0tDZe+V67TJwa/wAsvnsxXX63HKjH+blHVqIh8TblKviF/Dmoi8JwO3KSqn4nlmJdnBVtyFXclFQc9QNWpLyEhu5EkLLxfgUzgw4opTq5LBBjuebyMpRXegnlIDfTyC59zLr7wYxk/rqxkYllZ3KnAAsnNWdNVJLHLk0+c/cEll47SK/t2pVOnfrjuNb7PJ8AzwISKqQvVIBZApk9bL9OnbcJeQmbs3C0ICQkJqTYpALVr1y50HM4FE3c8DxIT+djzeASIdRzuiYlhYPB9d2BQUAVrrSqLNm2i9aRJnDpqFLz/PpSWQmwsK3yfV4GRnld1la2ANKAAE+YFtu+Vtg0m6jRgiydabcDTRo2yuLLvPM44I3b1E4OPOvmAA1rrYZ0+4JeVPhkZibhuY8zgviIbsJeMX7DqWb9UXETIIznpcOw58jzwKhadtKdJwkysQ0JCQvYUdYB1WEZHU2DyDlJcr8fSd1/NzuaQjAzyAFAtRmQGZmp/FpamGw+sWAGLhgH3+d64VU2bvQdMwHGG5uayNj2d//2GtjeQBQtW0fWIH4GlqBb9hmPtKb4C/ikiMapaddZByB+Kmgg8KVi50MpIoHIxprqsFpGG5VK0coL1v7C1cLQvVF5VIyRkN1Mv+GyARfF8V9WGrosPTELkQ3/o8+do9x7X0KLFbf7Q569yJr09SKLRGcB8VHPK75cPxVNUkRHDb5QRw7vqAQccq/93+2GcceYhJCePAVb5Ps8C9zlOtYXO2OCzFKvCtegP8sAJCQn5Y5MCMG3azBMcZ8tYIxKhIC6OHoA4Dn1jYnihgrCTX1hI/uTJ1B01irqTJkFhIcTHs8bzeBV4s7SU2arV7gNrYT4OHYBllVXO8n1isDSp/TABvwUFBYdQWnIAG/IyZNbMJSQkuGTuF0P9BkkkJaUHRvgAXP3ScIAmRCL7sGZNIUsWrycufpbut99CYuM2Yn4800RYJsKmarY7Mfg8AiuxPq2a++1KErG2h4SEhOwpamNVC7tg2SLbFeUzMsjPzuYibPJyMCJXYP14WyxavqwfewETeDLrQ/MuQA4kpKdTmptLL2AK8GZuLj3T0/lkJ9teP1hS+eNMph6H3aNSm89gsqqetHebFPJbqYnAswQ4EUvHqkh3LG9xZ5kIXAI8GHxOKLf+ahEZieVTbgz9d0L2EnWCzzjg+yoNj0XigdbYTG8L56q+LvC6f2XfIdrnimKJRkdtx9y4BIhDtRD4UEQ+l4sv6qZxcZ0YcF0rvfqaNqSnH+Ykxtckiq1M4GmJpSqMrMG+ISEhITtLCkCrVq3vULX0rMJCiIsjGfAch9Ndl01BhGKPSISSTz5BR40idfx4S+NKTGSTCKOAlyMRZqqyM2Vca2nt2kkcfngLvfqaQnyuwwb9zbEJpPqYCLR5kspqEyZjRbOAnj07q2ouSDaWIr4YpQgTznnrrbfObtKkSXbnzp1XkF4/g9p1GhEf3xrHOb1cOw6pgbgDNuAuxgSeTcCcnbj230oSFvUZEhISsvuxMXQK1u+0A74MUq62S0ZD+Szn21+H+A0aXpN/8z1O6iN3LcfG1GWeaMs2p+aKJM6Eq1oCt8DJiPjpMC03R0/BRJkJubl0T0+nZpVmLbulHpaWWwp8VKP99wIi8gF2n8tzooh8EIo8f2xqIvAMAYaIyEbgjWDdPiJyGeZw3rc6BxGRN4EeQD0R+QXLs38QGC0ifbB0r17B5u9iIco/YD/2y2rQ3pCQXUnd4LMUKnT6Vl2lJTZb0BL7XeUBX2IPll+d558zUWb7pualbBFkCEqhvy8is3jk4aPkkYc7aEKCUFzcE/h0c6n07VN2vMMxz4idnZUICQkJqQkpjRs3JjZW6olANAqx1htFXJcBItzqeXSbPh1/9GgYO5a4NWsgMZGS1FQm5eXxXFERH6tux6iezZUD62MztmXlbVti0TgZFEfSiY1zyraXCrHGqgq+X0JJSQnFxR4lJaUqThGJicUkJoLrJgG1QdKpPOXK7969O5FIZB9gBbGx84iN/YTs7AgzP63L0qWJsnFjLp9+msZns5waVNNKwp4JbYE5O+0b9NsII3hCQkL2JI2Dz3RsHP1FlVtunT7bNr1L8w25M5f8WtDvxtMS33rl2JiffliA6ra2BqpFV4ssTASawdedzJvtoPT6Mj//8RfOK+59xSRgUm4uLdPTayRw18GiLdOBxdWpfPs74MQarg/5g1BtgUdVXxCR5sDdwD3B6inYS+PD1S2vpqrnV/HVcZVsq0D/6rYxJGQ3UhaOvwFYijnPt8QidVpjQsomLJTUyjbWvAx5CRAnIqLl91XNA95BZKYUFx+NiTUdEfkSMwzd3gOoTOA5CFhRvopASEhIyG4kZezYib6IOJ5n2rbjUKhK1pdfMnTUKBgzBn79FSchAb9JE2Zt2sRjRUW8W1hIpOwgvk8CJta0C5bWmC9DQ2xAnUIQfVOpeOM4SknEw3VLcGOiqsSgmhC8HNiujhtHQmIcCf/P3p3Hx1XX+x9/fTJZ2nQvLd3bFLqyU7YCBdk3FQVRUPQni6BXwSvXBcWrInqVKwJXBUVAFJRNFhdERRRosQtbSwu0UNqS7nua7mmSmc/vj3OGpCFpkzaZk3PO+/l4zONkzkxmvhPKd855n8/3++0K7psx2wxsIJi7YR3BfGkt/Vw9cOC+i4Gn3f2yd9988ED46AVgth/B8c2pwGGYPUuwSsvuvh+6hp+7C/DvVv/V25cqeESkkAaH22KCkOS9S5Sb9SMMdQgqZnLAQqvZ/qzV1f2eruVFxYvenrOb9ynbDlwB0z4TrLJ1HHB0j2uuOKhk6nM3bfvyt9b3nTi2rX1fvhq0DJjSxt8VaVetXib93V8wGwGcTvAPeT3BQc2iDmibSOdhdgVw8Y8g9wK8bwwUdQEfCNM/Cz8E3gAWt+HqbJOXt6fYOTFveQys2T4EwyIPJrjCOwOY1mwZq9mBD8G9A+GIR4CfQxa4w92v2pN2iojsTr4/q6vLAUYuB3Pnkn34YTK//z0sWgSlpXDggSzo2pXb77uPhSNHMhYYR8PQqX4EY6SKg9fc+T3CQxdnV/P/udexfr1vXbfOX125snTr2jWWWbfeB9fuWDG+a9c5bNu2ivLyOYwbN5P3nbQQWFdU1BAuteWzNtr13r47CJPGAqcQHDutIlhd5e0Wgx6zz0yBr9bC6A+C1RS47zazIoL3vMHdv1OI9xSRlDP7CHA18OJhsO9s+CSQ6Q3Zs+BPDwaFBQMJ+v5Kgguq83ZzobPJW7TQZwcr3B5HcBG1GJgDTMF9fStf+JTn4OdZGHM+2KZOfLxtZl2BW4DPtfQcd9+buXUlYm0OeERSyey2bXDFNChdT5CqrCCYmKo3/PVmuJmguqeK4MrvptZW8DTzZZO364nOzPoTDHc8kGCuhmnAC7i/e4JyttlDH4YLxwKfh8brrd/eGb90RCTe8v3Zs89OY8CAY/nb3+Cll4LVr4YPh2OPJXf44dQPH05RcfEuw5vmbCOonFlDMBfOripr1ll5lz5Ldux4sRb6P02w1m4VQZnlYrhngfvl7fFZm3mo+b47CE0OJFjxpS+wFPgX7pVNn/p/ZpPHwYlvA1/c+aGC9N1m9k92rqzWxJsi0rHMvgB89Cbw78JJBxKU6eRX23F4aSj89D6Y/++gaj5LUMGzq23jn/8InNbMOzf0b0HQczzB0uH5oGdycxP0N3ad2VMnwBmVBMfbjUR+vN3Md9Vmgomg3yFY2bcp9fcx1+qAJ5xrZ4S7X9/MY9cD77j7ve3aOpHOwuyxLJw/D5hPUDvftdHDJcHwKofgcnIOcjXg2yG3FbJbg21uE9RvgexGyFZD3QbILofRVQQnHs3MJPd8+Lq5ZrY5wCug5FzoOw66bYf652DdP6BqB2SPgo9cG54/fWTn1826e1vm4BIR2S0zc4Dnn88xcaKRyez8eJNDjnqCOV42EoQ2iwly8yW8N7RZX1TEe+dT2HVjDqiG13uCLQPypcbhm3oJrNke9M91W6F+M9RvgrpNUFcNtethxzqoXQu1y2F7TaN+N9x+Yhfvfhfvfb4DuRLgHNjnLBjaE0rfgQ2/h3fmBAfdOcC/B9+cBHYn8ODOr9vhffceX3QQEdkbZjcAZ94AR+agCIJyx9cJyuSrO/bda2gUDnWH7ImQORoyxeBzoPYZ2L4uuMb7njDpm3DwaUAUffau7KI/n+nuR7RpBIHERlsCnleBX7n7z5p57PPAFe5+eDu3T6RzMBt6Eyz9CbA83FVEcAm2D3Ag/LkvlPWBst5Q1gNKu0NpDyjp2nArLoPiEigK/68zBzY2TOBMHcEl6m0ElyZKYelmyG0OQ6GNkFsP2SrIrgdfDbl1kK2DogooPRN6jIYumyE3GbY7jPw2wczK32/ykVR+KSLtLR/wTJ6cpbjYgPksXz6H119/g/79+337vPPOf2DQoMGri4uLHnP3Dj+oPMHM/wP4O0Gw05vgsmUPYDisKIficsiUQ6YMijJBRm/5PhrIr8dutUFo71vAt0FuDfTaTJDKbCI4+dgYbjfBmvXg1VBUH3xdGE22xVB0FGRODN7f5hH01Wug6G6wkcBFwf2ddHTfnf9v2Bx9b4hIhzF7Apg0DXrXEhwTbyY4Hs73tcfAA5tgezXUVEHNati+HLYtgpq3YNv6oMvOEPSzTbc/2sW7/6i539sHSj8EQyZCf4PMTKj+I6xbGXylZAimbCj+BXxoOMEqQU1LfaLsN1vTn5tZb4LRB99w9xsL1TbpOG0JeLYA57r7M808djLwJ3fv2c7tE+k0zCzfmTfVtnQ+GPval+Bco88H4fmeQK/w1p1glrZuwGXw+/DHri28d14NsJUgGyohOImo/xdcdAAUXQ08tjdtFhFphV0dTIZWEPRX+zXzWLuHPG3qt4O5csoJ+ud8H92LIMfvQdA19yToprs9ApeUh7/Q9Oj9JJgc/pgj+Lz57D5/vrKFIA/aRFDFNIJgRZha4PWn4LerwC5pTbvbSXiQfxnBkONmKeARkQ5jdgdw2d+g6G+Q6UXQ4fYgOBDuDn5eMA9P2S5eZQdBX7uVnbOhTZfArfkgvqrRbRut6NvMugOTgCMJwp9XCeboqcZs8N9g2VKwz773N6Ou4GlVYG9mS4Dn3f3igjRMOlRb/sHVE0x62Jzmlg4VSZo7aH5Vtzva9Cru2wkKgZYD/MXsH7RQDn+Z+4VA/sSjO0G1Tx/CcIiGE458NtSd4LuwHOhxBNT0hPJjeU/A07Y2i4i0Tkv92dME/c7lwDkt/G5HLM3a+n47uOK1Nbwt3d0Lf8xsMGGb8x1yH2B/ePkk+BkNuX2PRreeBJOEdiNYIas5UcBcTAAAIABJREFUk46Era9D9yE0VI222O42aqYk/9/AbOCSsF0iIlH4PrD5Wuj3WtAfNfVzd78KszIagvh8GJ8P5PPHxfk+Nz9hf9cvwoZNDavivqsbrMfsTwSB0FYahUI0FGZuIBg2/CeCSfMPIVgZcRZgI2DlQw2rgDUWl+Pt1wimPJIEaEsFzz+AYnc/pZnHniFY1fw9S52LJImZvQJMCO+22wz5HTYG1mz4Y/CHL8Hhy4KLzJ12Vn8RSYbd9WeFHgJkZrfREPK0ax+4V323WQnBSck+NJyg9CY4Obm8Do74P8h8rR3bvYv5GHLAb4GfEqwMqTl4RCQyZvYCwYpW0B79X9jfHgWPl8CkPgRp0CiYe0PQ9+UD+PzF0nKC6vmiFl4xR1D8UAcMAgZ/AJ59Ej4W/k6nON5u7ZxqZnYj8F9AN3dv23x30um0JeB5H/BPggUo7ia4qDQE+AzBCe/p7v5cxzRTpHMws4eAI919VNRtaQsz+xZwA1CqjltEOpoFVYdrgcfc/bNNHit0wNMXWA982d1vae/X7xBmQ4H/HA6XLoXfu/vnd/s7rXrZVpfrr2Hn6myFOyJSMGZ2N/B+dx8UYSMyNBRoNq4WajqzwlnAKOBWg9XATUBPd98cRbObas2FCDP7JEHQdZC7v1HI9kn7a/UQLXefbGYXAP8H/LLRQ5XARxTuSEqMIPg3Hzcbwm1vgpMuEZEO4+5uZnOBA5p5uMVhqR3UnIpw+04HvX77c18GfHWp2XkE/XahbQGecfeLInhvEZFhtGKobIdyzxJcHFi/y+eFgTzwE+DscG8vgmFekWtlOP9auD2IYNEyibGWys6a5e5/cveRwHiCiabGuft+7v7nDmmdSOdTQbCUb9zkA56+kbZCRNJkLnBgWM3zrvBgs2mY05EVIiPDbWUHvX5HqqbAAY+ZlRN8180t5PuKiDQylKgDntZyX4b7V8NgPr+aexTB/N64Kdw+ZGYeVv1ITLUq4DGzUjObaWZnALj7W+4+zd3nd2zzRDoPM+tCMDlmZcRN2RP5VRvfM7mciEgHmUvQ5wxo+oC7n+nu1ujWkcN/KsJtfCp4GmygfU8UWqqSarx/LMGcbfPa8X1FRNoi+gqePbMx3PaKtBVtEIY5pzfZfYZCnvhqVcDj7rUEV8DqO7Y5Ip3a8HAb5woeBTwiUij5Mu/mhmkV0khgo7tX7/aZnU817dhvt7J6any4VQWPiBScmeVXH1wWdVv2QOwCHlpewbIjVraUAmjLEK2n0X9oSbcR4TbOAY+GaIlIoXwr3P4r4pLvCuJZvQMdMESrFdVT4wlWgHm7Pd9XRKSVhoXbOFbwxHWIliRIqydZBn4G/M7MioE/AiuBnVZjcPdF7dg2kc4mH/BURtmIPaQhWiJSMGGY874mu88ws6ciWI2pgviGFQWfg4eg4mphWL0tIlJocQ544ljBIwnTloBncrj9L+CaFp6T2bvmiHRqFQRXNZdH3I49kb+ioIBHRAqhU5R8hxM8jySoQo6jDUAXM+vi7jUd/WaNl9MNl1TX8ugiUmhDw60CnsIo9MqW0sHaEvBc2mGtEImHEcAyd4/dXFTuXmdmW9AQLRFJl35AOfEeogVBFc+qjnyjxuFOI1FVXYlIeg0DcgSjReKmBqglRkO03P3MZvp/hfsx1uqAx93v7ciGiMRABfGcfyevClXwiEi6xHmJdChgwEMnqboSkdQbBqyM6QVVN7ONxKuCB4U5ydKWSZZF0m4E8T1JgKDUXwGPiBRCa5bjLoSKcBvXCp78BPmxuRosIrKX4rpEel4Uc6eJvKvVFTxmds9unuLufvletkekUzKzEmAI8a7g2YCGaIlIAXSiku+KcBvXvlvzp4lI2gwF5kTdiL0QuwoeSZa2zMFzCk1WzSI4WexBcABS/Z7fEEmOoQQVb3E9SYBgiNbYqBshIunQSUq+RwJV7r4p6obsoUIuuauJNkUkUuHE+MOAv0bdlr2ggEci1eohWu5e4e4jm9x6AScRjAv/SEc1UqQTiPMS6XkaoiUiaVNBfIdnQQEDnjCQaxrmaKJNESmkPgQT42uIlsgeaksFT7PcfYqZ3Qr8DJi0900S6ZQqwm2cK3g0REtE0mYk8HrUjdgL+Tl4ChLOK8wRkYgNC7dxDnhUwSORaq9JlhcBh7fTa4l0RiMIhijG+QunCuhiZl2iboiISEcLS/1HEOMKHnevAXagq8Eikg5JCHhUwSOR2uuAx8yKgUuAZXvdGpHOq4JgycYdUTdkLxT0SrCISMQGAF2I99Ba0MmCiKTH0HAb5/PKjUC38BxZpODasorWM83sLgXGAPsAn2uvRol0QiOI9/AsaAh4+gIro2yIiEgBjAy3lVE2oh1sQAGPiKTDMKCeYH7XuNoYbnsSVM+LFFRbksUi3ruK1mbgceAhd39uTxthZmOBhxvt2g/4NsEBzRXA2nD/de4e51nVJb4qgBlRN2Iv5b9kVMEjImlQEW5jO0QrVI36bRFJh2HACnfPRt2QvdB4cnwFPFJwrQ543P2kjmqEu78FHAZgZhlgOfAH4FLgVnf/cUe9t8juhP8mh7FzCBlHGqIlImmSr+CJe/VlNdAv6kaIiBTAMOI9/w40VPBoomWJRHtNstyeTgUWunvcD8gkOQYRhKGVEbdjbzUeoiUiknQVwBp33xp1Q/aS5uARkbQYSvwDnnwFjwIeiUSbAh4zO9jMHjWztWZWb2ZrzOz3ZnZwO7bpIuDBRvevMrM5ZnaPmanyQKJQEW7jHjpqiJaIpEkF8Q/mIQjn1W+LSKKFKx8OJd4TLENDBY+CeYlEqwMeMzsKeAE4GfgLcBPwJHAKMMPMjtjbxphZKXAu8Ei46xfA/gTDt1YCN+/te4jsgRHhtjLKRrSDjQTzaKmCR0TSYCTx77chrOAJT35ERJKqH8HKh3Gv4NEQLYlUWyZZ/iHwOnCqu2/O7zSzHsA/w8fP2Mv2nA3MdPfVAPlt+D53EQRLIoVWEW6XRNmIveXuOTPbiK4Ei0jCmVkRQTj/WNRtaQfVQAboBmyJuC0iIh1lWLiNe8DTeJJlkYJryxCticAPG4c7AOH9/wWObYf2fJxGw7PMbFCjx84jCJhECm0EsNbdt0XdkHZQhQIeEUm+wUAJyangAZ0siEiyJSXg2RRuVcEjkWhLBU/TJdLb+vgumVk5cDrw2Ua7f2Rmh4WvXdnkMZFCqSAZJwkQzOWgIVoiknQV4TbuS6TDzisgxn1uChGRlgwNt7Hu59y93sy2ooBHItKWgOcF4Doz+2eTIVrdgGuBGXvTkLA6Yp8m+z61N68p0k5GAHOibkQ70WSdIpIGFeG2MsI2tBdV8IhIGgwD6oA1UTekHWj1Q4lMWwKe64DngMVm9heCSY8HAu8HugIntXfjRKLWaB6HP0fdlnZSRUMJrIhIUo0Mt3Ff/RAU8IhIOgwDlrl7LuqGtIONqIJHItLqgMfdXzSzicC3gTMJhnlUAc8A33P31zqmiSKR2hcoIxknCaAhWiKSDhXASneviboh7SA/REsBj4gk2TDiP/9Onip4JDJtqeDB3ecAF3RQW0Q6o6QskZ5XBfQxM3P3vZo3S0SkE0vKEunQUMGj4bUikmRDgelRN6KdbAT6R90ISae2rKK1EzPrZWZHmtnQ3T9bJLYqwm2SKniKCZbbFRFJqgqSMcEyBCcKoKvBIpJQ4ZQIQ0lOBY+GaElkdhnwmNmZZnZjM/u/STAB1gsEc/I8YGZtqgYSiYl8BU+SAh7QMC0RSajweGQ4Cangcfc6YCsKeEQkufYFSkhOwKMhWhKZ3YUyn6PJ8udmdjrwPeA14G5gPMHy5a8AN3dAG0WiVAFscPdNUTeknVSF2z7AkigbIiLSQYYAGRIS8IS0AqKIJFl+AZCkBDwbgV6aEkGisLuA53CCMKexS4Ea4Ex3XwVgZgCfQAGPJM8IklO9Aw0VPDpREJGkqgi3SRmiBboaLCLJlg94lkXaivZTDZQCXYDtEbdFUmZ3c/DsCyxssu904N/5cCf0JDCmPRsm0klUkLyrwKAhWiKSXPkl0iujbEQ7U8AjIkmWn9M1SRU8oHl4JAK7C3g202gyVjMbDewDzGjyvE0E5dAiiWFBaVrSKngaD9ESEUmiCoLh5UkahroBBTwiklzDCEaIrIu6Ie1EAY9EZncBz5vAhxrd/xDBQdM/mjxvJLC6Hdsl0hn0JQg4kxTwaIiWiCTdSGC5u9dG3ZB2VI36bRFJrmHAsgTNV1MdbhXMS8Htbg6eW4HHzawvQYBzCcHkylObPO88YHa7t04kWhXhtjLCNrS3LUAWDdESkeSqIFn9NmiIlogk2zCSM/8OqIJHIrTLCh53/yPwJeAo4P8RDM36aON01cyGAicDf+3AdopEIWlLpBP+v1uFrgSLSHJVkKwJliEIeHqa2e4qr0VE4mgoyZl/BxTwSIR2V8GDu/8U+OkuHl+GripJMlWE28oI29ARtNyuiCSSmZUQnChURtyU9rYBMIKThQ27ea6ISGyYWQYYQrICHg3RksjoSpBIy0YQDGlK2sH0BjRES0SSaRjBsU0SK3hAJwsikjwDCRbrSVLAowoeiYwCHpGWVQCVCZrwLU9DtEQkqZK4RDoo4BGR5BoWbpM0B88WIIf6bImAAh6RliVtifQ8DdESkaSqCLeVEbahI+QrSXWyICJJkw94ElPBE14c3ogqeCQCCnhEWpbkgEdDtEQkiSoIVgpMzIlCKF/Bo3BeRJJmaLhNWr+tgEcioYBHpBlm1ovgSmllxE3pCFVAb63GIiIJNBJY5u71UTeknWmIlogk1TBgG8mb87Ia9dkSAZ3giTQvcUukN5JfjaVn1A0REWlnFSRvgmVQwCMiyTWMIJhP2pyXquCRSCjgEWleRbitjLANHSV/hUTDtEQkaUaSzH57E+BoiJaIJM8wkjc8C1TBIxFRwCPSvCRX8FSFW50oiEhimFkZMJgEBjzuniO4GqyTBRFJmqEkM+BRBY9EQgGPSPMqgBpgTcTt6Aj5Ch4FPCKSJMPDbRKHaIGuBotIwphZMTAIBTwi7UYBj0jzRgCLEzgeGDRES0SSaWS4rYyyER1oAwp4RCRZBhOcjyYx4KkGemlREyk0/YMTaV4FyRyeBRqiJSLJVBFuk1zBo35bRJJkWLhdFmkrOsZGgkVNukfdEEkXBTwizRtBsq8Cgyp4RCRZRgL1wIqoG9JBNERLRJJmaLhNagUPqN+WAlPAI9KEmXUD+pHQCh533w7sQFeCRSRZKoAl7p6NuiEdRAGPiCRNvoIniQHPxnCreXikoIqjbkBjZlYJbAayQL27H2lmfYGHCQ7cKoGPufuGll5DpB3kV9CqjLIRHawKBTwikiwVJHd4FgTVl+q3RSRJhgGb3X3jbp8ZPwp4JBKdsYLnZHc/zN2PDO9/HfiXu48G/hXeF+lISV4iPW8DGqIlIskykmQH89VAuZmVRt0QEZF2Moxkzr8DGqIlEemMAU9THwLuDX++F/hwhG2RdKgIt0kPeHQlWEQSwcy6AgNIdgVP/mRBV4NFJPbM7DbgPGC8mdWH95NEFTwSic4W8DjwDzN7xcyuDPcNcPeVAOF238haJ4kXfrncHt6tTOCXTf4zHgecnNAvVBFJkbAP2xzevSHBfdoHw+0a9d0iEmdh//WFRrsywBcS1q9dG25/pz5bCsncPeo2vMvMBrv7CjPbF3gauBr4s7v3bvScDe6uygNpd8182eTd7u5XFbo9HSENn1FE0iMtfVpaPqeIpIOZ1ROEOk1l3b1TzRG7J9RnS5Q6VcDTmJldD2wBrgBOcveVZjYIeM7dx0baOEmkpH/ZQDo+o4ikR1r6tLR8ThFJBzNr8QTU3a2QbekI6rMlSp1miJaZdTOzHvmfgTOA14E/A58On/Zp4E/RtFBSoLmOeFf74ygNn1FE0iMtfVpaPqeIpEO2jfvjRn22RKbTBDwEkyP+28xmAy8CT7r734EbgdPN7G3g9PC+SEdI+pcNpOMzikh6pKVPS8vnFJF0uKON++NGfbZEptMEPO6+yN0PDW8Huvv/hPvXu/up7j463FZF3VZJrKR/2UA6PqOIpEda+rS0fE4RSYFwHppHG+3Kkqz5adRnS2Q67Rw8IlFoMilaFrgjQV82wLuf8T8IAt5EfkYRSY+wT/s8YCS4TzOz+4BPhXcT+zlFJB3M7ARgCnCau/8r6va0tzScU0jnpIBHpBEzy58gfM/dvxN1ezqKmX0Z+DHQ09037+75IiKdmZn9BjjZ3UdE3ZaOYmZDgaXAle5+V9TtERHZG2Z2OvAPYJK7T426PR3BzKYDm939jKjbIunRaYZoiXQSXQmuAm+LuiEdrD7caiZ/EUmCcpLfb9eFW/XbIpIEXcJtTaSt6FjbCc4tRApGAY/IzrqF262RtqLjKeARkSTpSnAgnWT5frsk0laIiLSPNAQ82wguQIgUjAIekZ3lO2EFPCIi8ZGmCh4FPCKSBPmAZ0ekrehYquCRglPAI7IzVfCIiMRPmip41G+LSBKkoYJnO6rgkQJTwCOys7QEPNlwqxMFEUkCVfCIiMRLWbhNcsCzDVXwSIEp4BHZWT7gSfqJQv5KcCbSVoiItI80BDyq4BGRJElLBY8CHikoBTwiO0tLBY9OFEQkSRI/RMvdnaD6UhU8IpIEaQh4NMmyFJwCHpGdaZJlEZH4SUMFDwTDtBTwiEgSdAGy7l6/22fG13YgY2bqt6VgFPCI7EwVPCIi8ZOWgKce9dsikgxdSPYKWtBQWaoqHikYBTwiO0vbHDw6URCRWDOzIoIThUQP0QqpgkdEkqILyR6eBQ3nE5qHRwpGAY/IzlTBIyISL/l5HJIezEMQ8KjfFpEkKCP5AU/+woMCHikYBTwiO8uXUCb9SrCWSReRpMgfOCe934YgnFcFj4gkQZoqeDRESwpGAY/IzroB29w9F3VDOpiWSReRpMgfOKuCR0QkPtIQ8KiCRwpOAY/IzrqR/OFZoCFaIpIcaQp4VMEjIkmhgEekAyjgEdlZN9JzkgAKeEQk/tI0REuTLItIUqRhFS0N0ZKCU8AjsjNV8IiIxEuaKng0REtEkkKTLIt0AAU8IjsrRwGPiEic5A+c0xDwaIiWiCRFmoZoqYJHCkYBj8jOVMEjIhIvaVn9EFTBIyLJkYaAJ3/hQRU8UjAKeER2lpY5eLRMuogkRZqGaKmCR0SSIg0Bj4ZoScEp4BHZWdoqeLRMuojEnSZZFhGJnzQEPJpkWQpOAY/IzjQHj4hIvKSpgkdDtEQkKdIQ8KiCRwpOAY/IztJWwaMTBRGJuzQFPBqiJSJJUUbCl0l39xxQiwIeKSAFPCI7U8AjIhIvaRuipX5bRJIgDRU8EFx80BAtKRgFPCIhM8sQfNmk5Sow6ERBROKvHKhz9/rdPjP+VMEjIrFnZkVAKekIeLajCh4poE4R8JjZMDN71szmmdkbZvaf4f7rzWy5mb0a3s6Juq2SaPl0PQ0VPFpFS0SSoivpCOZBkyyLSDKUhdu0BDyq4JGC6Swnd/XAl919ppn1AF4xs6fDx2519x9H2DZJjzQFPKrgEZGkKCcdw7Mg6LvVb4tI3HUJt2kIeLahCh4poE5xkODuK4GV4c+bzWweMCTaVkkKdQu3aQp4tEy6iMRdOargERGJk7RV8CjgkYLpFEO0GjOzCuBw4IVw11VmNsfM7jGzPpE1TNIgH/Ck4URBFTwikhRdSU8FjyZZFpEkyFfwJHoVrZAmWZaC6lQBj5l1Bx4DvuTum4BfAPsDhxFU+NwcYfMk+dJYwaMTBRGJuzRV8GiSZRFJgjQN0VIFjxRUpwl4zKyEINy5390fB3D31e6edfcccBdwdJRtlMRL0xw8uXCrgEdE4i5NAY+GaIlIEqQt4FEFjxRMpwh4zMyAXwHz3P2WRvsHNXraecDrhW6bpEpqKnjc3dFknSKSDGkaoqV+W0SSIE0BjyZZloLqLAcJxwOfAl4zs1fDfdcBHzezwwAHKoHPRtM8SYnUBDyhLJ2nDxAR2VPlwNKoG1EgquARkSRIU8CjIVpSUJ3i5M7d/w1YMw/9tdBtkVRL0yTLoCvBIpIMaarg0STLIpIEaVpFS5MsS0F1iiFaIp1E2ip46tEy6SISf2mag6ceyIRD20VE4ipNq2ipgkcKSgGPSIM0TbIMquARkWRIU8BTF241TEtE4ixtQ7RKzUwXVaUgFPCINOhGsLpUGq4mgAIeEUmGNA3Rqg+36rtFJM7SFPDkL0CoikcKQgGPSINuwLZwhak0UMAjIrFmZiUE1Syq4BERiY80BTz5CxAKeKQgFPCINOhGeoZngQIeEYm//AFz2gIe9d0iEmdpDHg00bIUhAIekQblpCvg0TLpIhJ3+YAnbUO0VMEjInGWtlW0QBU8UiAKeEQaqIJHRCRe8ldE01bBo4BHROIsbatogQIeKRAFPCIN0hjwaEZ/EYmztFbwKJwXkTjrAtS5ey7qhhRA/gKEhmhJQSjgEWnQjfRcBQZV8IhI/KmCR0QkfrqQjuFZoAoeKTAFPCIN0ljBo4BHROIsrQGP+m4RiTMFPCIdRAGPSIO0TbKsgEdE4i6tQ7RUwSMicVZGegIeDdGSglLAI9JAFTwiIvGiCh4RkfhRBY9IB1HAI9IgbXPwaJl0EYm7/AFzWvpuVfCISBJ0IR0raEFDwKMKHikIBTwiDVTBIyISL/kD5rQM0dIkyyKSBGmq4MlfgFAFjxSEAh4RwMxKCA6Y0xbwaJl0EYkzDdESEYmfNAU8GqIlBaWARyRwe7j9npnVm9ltkbamMFTBIyKxFfbTt4Z3V6eo3wZV8IhITIV99cnApDQcc7t7HUHfrSFaUhAKeCT1wi+WKxrtygBfSPIXTvjZzgKOSsOXq4gkS9hnfYGG45jE99uh/wy3T6nvFpG4adR3W7gr8X13+NmKgW+o35ZCMHePug0ikTKzloYqZd09cRUujb5cm7rd3a8qdHtERNoqbf02qO8WkfhLW9+tfluioIBHUs/MWvyfwN2tpcfiKm1friKSPGnrt0F9t4jEX9r6bvXbEgUN0RIJlgtvy/64a2liZU24LCJxkbZ+G9R3i0j8pa3vVr8tBaeARwTuaOP+uEvbl6uIJE/a+m1Q3y0i8Ze2vlv9thScAh5JvXAM7PONdmVJ9tjYtH25ikjChP3znCa75yS43wb13SKSDN7kZx1zi7QjBTySOGZ2WzhLvbdmtvrw8Unh3SxwR4K/aPInRrfz3i/YZrX17yki0lZ72G8f0mT3IUnun9oSaqnfFpFCaEtf08wKWjT5OXHaejFCfbe0B02yLImyu9nqzcyAUqArUA7cCHyqped3XEuj1dpZ/TX7v4h0tFb020UE/XUPoHt4e4mUTVypfltEOpPW9DVm1gXYJ7zNRP123nv6Y/Xd0l4U8EismdkngB8Aw4ElwDBarkzbSnCS0JqrBYn9soFdzuqfA/47fCwDfJuW/55O8De/zt0f6Ih2ikgyNem7d9UnbwW6teW1k7gSC+y2374GKA5vP6T5fjsHLKXh+1J9t4i0WhuPuZcA/QiOu3crpf32pTQcb2eAn6NjbmkHsQh4zOws4CcE//jvdvcbI26SdALhF81dtPLLA7gF2A5sa7RtcQxsUr9sYNfLVO6BbcAV+sIRkdZoY999C7AF2Bxu87dHSd+V4PY+YFPfLSKtsgfH3PcB64F14XY98BDqt/eW+m3ZrU4f8JhZBpgPnA4sIyjL/ri7z420YRI5M6sERrTy6c1+eewiWU/slw3s+nMTDH/IhrfaFp7X1GJ3r2i3BopIYrWh726xH05jKftu+u19gfrwtqmF5zVHfbeI7FY7HXOr326QBcbScLydJajQ0TG37LU4TLJ8NLDA3Re5ey1B+vuhiNskncPwNjy3rbPYJ312+xY/t7vXuHudu+d28bym2vLfQkTSrbX9xa4qLPOTxeeXmk366oew6367yt03ufsuK1Obob5bRFpjr4+51W/vvN/dF7p7pbsvdfcVu3huU+q3ZZfiEPAMIRgznrcs3CeypIX9m2nll0dKv2xa/bmbeV5LWvpvISLS1O76i1b1w+5+lbsXu7uFW/XbLT9vcwsvq75bRFpjr4+5Qf02u/gb6Zhb2kschmh9FDjT3T8T3v8UcLS7Xx1tyyRqLYwH1tjUDqS/uYjsLfUjhae/uYjsDfUhhae/ueypOFTwLCOYpT1vKLAiorZIJxJ2blcAiwlml1+MOr0Opb+5iOwt9SOFp7+5iOwN9SGFp7+57Kk4VPAUE0yyfCqwnGCS5U+4+xuRNkxEREREREREpJPo9KsEuXu9mV0FPEUws/g9CndERERERERERBp0+goeERERERERERHZtTjMwSMiIiIiIiIiIruggEdEREREREREJOYU8IiIiIiIiIiIxJwCHhERERERERGRmFPAIyIiIiIiIiIScwp4RERERERERERiTgGPiIiIiIiIiEjMKeAREREREREREYk5BTwiIiIiIiIiIjGngEdEREREREREJOYU8IiIiIiIiIiIxJwCHhERERERERGRmFPAIyIiIiIiIiIScwp4RERERERERERiTgGPiIiIiIiIiEjMKeAREREREREREYk5BTwiIiIiIiIiIjGngEdEREREREREJOYU8IiIiIiIiIiIxJwCHhERERERERGRmFPAIyIiIiIiIiIScwp4RERERERERERirqABj5ndY2ZrzOz1RvseNrNXw1ulmb0a7q8ws+2NHrujkG0VEREREREREYmL4gK/32+A24D78jvc/cL8z2Z2M7Cx0fMXuvthBWudiIiIiIiIiEgMFTTgcfcpZlbR3GNmZsDHgFMK2SYRERERERERkbjrTHPwnACsdve3G+0baWazzGyymZ0QVcNERERERERERDqzQg/R2pWPAw82ur8SGO7u683sCOCPZnagu2+KpnkiIiIiIiIiIp1Tp6gwp2Y7AAAgAElEQVTgMbNi4Hzg4fw+d9/h7uvDn18BFgJjommhiIiIiIiIiEjn1SkCHuA04E13X5bfYWb9zSwT/rwfMBpYFFH7REREREREREQ6rUIvk/4gMB0Ya2bLzOzy8KGL2Hl4FsCJwBwzmw08CnzO3asK11oRERERERERkXgwd4+6DSIiIiIiIiIishc6yxAtERERERERERHZQwp4RERERERERERiTgGPiIiIiIiIiEjMKeAREREREREREYk5BTwiIiIiIiIiIjGngEdEREREREREJOYU8IiIiIiIiIiIxJwCHhERERERERGRmFPAIyIiIiIiIiIScwp4RERERERERERiTgGPiIiIiIiIiEjMKeAREREREREREYk5BTwiIiIiIiIiIjGngEdEREREREREJOYU8IiIiIiIiIiIxJwCHhERERERERGRmFPAIyIiIiIiIiIScwp4RERERERERERiTgGPiIiIiIiIiEjMKeARKSAzm21m3sJtW5P7s6Nur4hI2qnfFhERkbgwd4+6DSKpEB74H9LGX5vj7od2RHtERGTX1G+LiIhInCjgESkQM9uj/9nc3dq7LSIisnvqt0VERCRONERLREREREREOpVmhshqGKzIbijgERERERERkU6jhSGyhyjkEdk1BTwihTOnQL8jIiLtQ/22iEg0Wpr/7BBV9Ii0rKABj5ndY2ZrzOz1RvuuN7PlZvZqeDun0WPfMLMFZvaWmZ1ZyLaKtBszw2ywux9aBK8VA12A7kBvYB9gADAUakYA+wNjgCPgLYelmG3C7PjI2i8iklLhZMm7Cmy2N7n/mrsfitmBHdgsEZHEyg/LauXTVdEj0kRxgd/vN8BtwH1N9t/q7j9uvMPMDgAuAg4EBgP/NLMx7p4tRENF2tH/AFdjVrYcXnkIcFj5JbM7n5sw4bStRx9z/OBNm16ecP/vngSK7oYvdoNeZ0EVcBaQAX5NkPuIiEghmC0DejvccBocXAq1f4WPPQWjHurR4+YhdXUzvl9TcxdQcgNcvRUOPBW2Y1YF9MTsctzvjfhTiIjExh6uXNjW54skWkEDHnefYmYVrXz6h4CH3H0H8I6ZLQCOBqZ3UPNE2p+ZAWcDXYFM36FDjzjj5FPY98yz+uZOP/3aE/fp1wVg8R//MIj7f7c/MOhY2LYUev0GjjgDikaDr4HaoWaGlr0TEel4ZqcCAwkC9uuvBtsSVD2fdhysLf3BDzjknPdP8KOO7G5VVeMvh6r5QFc4CLDw927H7D712yIiraawRmQvdZY5eK4ysznhEK4+4b4hwNJGz1kW7hOJDR9/wBdyn76kPPfLO3fUzZufy1QuLRn763spPeXUsi0vvbRl65evWV41ej+GXHD+AGAYMOMe+POHgP+C0ofBloEtgvE/h1sj/jgiIskXBPNXAWtroea3UFMFDILiZXBa98MOO/vEKz9L+VNPFVtV1YXA+CGw7q/gV0DpN2HLDmAuFD8Cd0f6WUREEswIpjrA7ADMTsLsQsx+g9mfMOsXcfNEIlHoIVrN+QXwPcDD7c3AZQT/zzalq2DSqWWzlAOTgFPJ1p/O7NcOp6gI37rVX31+iv/lrl/y2ssv8/LzU+jn3u1+WDcQKA3+XxwN3DC7W/f7LztiAvU1Nez74otkgTIoOgM+j9kvcZ8X5WcUEUm4/wH6V4P/GjL/B31KgJ5gR8B+N//4x5u619TQ5frvFAHjge8CCxaZnX1gJtOF+vr+S4ByKDsSLrnWbMn/un83yg8kIhJ3vYF9m9z6BftXAx8LnzYOOBQYDnwb+GLhWyoSrcgDHndfnf/ZzO4C/hLeXUZQ0ZA3FFhRwKaJ7FY2SzFwFHBqeDsOKK2vr8+tnz6tqOuzz8DyFc4++7DvCScUXfvf32bx5Od4fMpk3g9duxUVjXpx1CiOOu742t6TTujpRx/z5N/Gju1SlMkw77FHeefCj1IK9AeGQslzmczck+3d7DML3OHuV0Xx2UVEEsdsAPBxoNdG6DEBiq8ZOZJDLr6YGT/5CcMPPrisxymn9t/4/e977dq1vi9sC5//549ecmnJCV/8Ik+eeQYla9YAMASKPllWdn2Z2fW16rNFRFpmZgZzusMhTYOc/WBVLfRzLDPshEm2raiI6ZMnsxiq/wofBo4AjgHKge+HP2/H7GjcX4zqI4lEwQo9NDycg+cv7n5QeH+Qu68Mf74GOMbdL7JgBYoHCObdGQz8CxitSZYlStksRjDx92kEgc77gB4E1WWvAs9+5zvfuah46z6DR/Y6hU98qYKiHt0BqJ43j1dnTOetpUs4obSM4aedRumBB1HatWvw4nV123jllZq3n/lXj3unTy0peeEFjikr4+CJxzJ74kQmTTyWbocdzqVDB/HA5s2Nm3W7ThhERPacmd0GfO6RiorMyZWV9AaqgTeAorvu4siLP8lJ++/HE488So8RI3hj3ry6VTt2FL3/gx/4NHC5jx23csv06Z9YM3s2D55yMue68yhwev/+HPXyK/ztum9w/v33599uTrg6l4iI5JmdAnzrVTj6X1CeP9J1WHF9166fu+UTF//P+y67/OAJEyeyZcuWqb169Th+FNS9DdcDnwd6AjcQjAYx4EKCBUoexH1+BJ9IJBIFDXjM7EHgJIKKutXAd8L7hxGcIFcCn20U+HyTYLhWPfAld/9bwRorEspmqaChQucUglXNAd4GngOWrVpF72nTOG327OxBL76YsZUrgyd857NPcGhmBfsMGkjRhCPpMSSYRsrdMTNyuRyLFy/mzjvv4Kc//QnXHD7Bv3jMRLocc4zlJh5L7+HDAajdsYMFM1+hywszWP6/N3Lh2rWsadREd4+8Gk9EJI7CcOcLJ+27L/9cuow3v/F1/nrLLRwJ7BgxgtPmv80rv7yDssmTOfSRR3ni1lu3fvCaa7pde+3Xcj+66aZiLyr64pbHHvu/8jPO5FuHHsLdCxZwP/AscOwjj3L2Bz7AzCMmcO3cuTzX8LYK5kVEGjO7hGDI65BFsPw+GD6kvPzty2/83/lceNGx9OvXd93Chbx0+21V5zxw/413r1177f6wz0FQvW9wsTUDLAdG4J71qdMG8sMfXGFPPpkF7sF9VYSfTqRgCl7BI9LZZbP0B06moUpnv/ChVQSBztK6OspefpkTXn2Vg6dPp/j11yGXg7KyOsZVrOG0Y5wTztuXipGlO792TQ11b7zO6lmzWJ3LUTJqNIMPOIDSkhK6d+9OSVkZADsqK1nz8ku8umwph9XV81q/fgw69DDKly1l1fkfZjFB8pnn7s3NWSUiIrthZvVAZtZXvsKhP7qJ9x8wnr+9+SaPAxV33MH4T1/C0+PHceY/nmbb9u1U19RQPnhw7kfXf79o/W/u4pyPfIQLHnqYxV/9ClNuvpn/BO4Bij/xCT7wu/t5e84clp59FvUrV3IRQWUQCuZFRHYWBDzHAH3ePPqYP0w944yHLrjqau/Rv7+xYME67vzlwqmPPXpYfWVl2QnwbBYGvQHjNoKfBJUGg7xnz7e44sqt/Nd/waBBR1Nb+4x1Kfs7wcJCd+G+KcqPKFIICngk9bJZugMn0lClky+d3wRMAZYAJUuWcPhLL3H49OlkXngBNm8GM9hvPzZPmkTRSSfR7aCDoLjYw0VYYMOGOpa9No19V6ygft992WfUaEqHDKEok3n3/XPZLNuWLaNy+jSWbt/O9p49OXzceCrGjcPC521cu5YZM19h2nPPMvKmH7E/8HPgkeAl3N07y4p4IiKxYmb+ceCueW+yfUcty+nGhRd+gJu3beHMtxfw0q/upt+bbzLqJz/lVz/4Hy6/7pu89tAjjPzAR/nDxefxgbvv5O1Fi/ju8cfx5VyO1UD3QYM44/U3qCkqIpPJ8LPDD+PYhQtZSzBmABTMi4jsxOw232+/S/xL15Rz+eU5unTNvP3kk4zeuvW3HHroAEaNOmHerFkrTj3mqP3/CG9MhMFTofiLJSU9PnLOObWXf+zC0j7nnktJt26wevUOpkyZy8aN19uVV7xAcF10A/Br3HdE/ElFOpQCHkmdbJZSYCINgc4xBBOO7wBmAIuBoq1bGTdrFhOmTaNo+nR4553g9/v2pX7SJDLHH48dcwz06hUEPe6wcoWzpnIjGdtIj8GlDB3an+LinS/Sbt64kVVLl1C1ehXFOWf/ipH0Hj363cfXL1vGO7NmUjNrJkNnzqTnrJlULV/ORwjmg6gAfgJ0BS4G1irgERHZY6VmuWcnTbLjpjzPizNmsk//oRx00HBev/VWRl52Oa8cMYEDnn2OGbNnM3z4cLLZLP37DKPm2ad5M7eNEy64gAkTDmfu3LmcBFwHHP2XJ+l+2mkUlZZy+eWXce+vf81dBOWg9/Pu2ukapiUiiWFmnwB+QLCC1RLgOnd/oDW/m1tUeZwvWfJbO/74/chm4c9/yq5YsYLeZ52dKR8zBnbsqKWy8tmaBx/45z++d8OP+mcydcdd/Mm/zfrsZwdUjBs3sU+fPtSuW8e8R37PVx9+uGbiv/+9aFIuN74E7Dngb8A5QbH9v74HZ+Ge67A/hEjEFPBI4mWzFBFU5eQDnRMJZtnPEUyMvAggl2P/BQs4dPp0iqZNw2fOhLo6rLQUjjgCjjsOjj0W9t8/CHTq6mD5cry+nk39+5Pr0T3XsyhTlGn83vV1dbByBcVr1rCjPosPHUqXoUPffXz7woVsfXUWdbNmUjVrJptnzaJuTcPsOj3ChmcIJq26BXgq3HcJsI7garCuBIuI7JkbzXKfvufX1vv886nJdeeWW37Ig7+5g/kLFpL79T2sq66m/1e/xtT/vZETvnEdi555nr4HH8mir1/NhF/dzexvf4s3v/99SgmuFIy77DJG3/0rvL6exX/8I9d+7KNMAWqAe4FuwH8ACzRMS0QSIj+XWZPdtcClLYU8uRwGnAl8bf58Tn7gd1m/aNRLNeOGby/1E99XZEVFtnDyZFbdd2/9yMcfmz9k8+YcRx01tvoTF1N/wQUl/QYPZvv27T5//nx76qmn2PLf3+Sk+no+BlQRTPj6BYLVUGoILpJuBdbAX26Hc9FJsCSUAh5JnHClq/0JwpzTCObT2Sd8eD6wkCDcGVFVxYEvvIBNnUpu+nRYv54iCEKc446DiRODcKdLF9i6FdavJ9etGzt696Y0kyHT9L3rqqpYs3YNxXX19Bk4kNJ+/YIHcjlyb73FolkzWTRrJlNnzeTteQvJdRlE14Hj6TZwPLOe+gFbazZRB3QBzgZGEiwPOQqYAwwkGES8juDySD1wP+Rud39PW0REZDfMBj/Ts+fyE1asZPbct9hv/0O4/5AKzv3G1xl2xZXY+07En3mW1Y8/Tp9TT6Vm1Soy+x/K2zd9n9FXXk7NujU8etSR7KivZwfQc/hwLp/zGsWZDFZdzbpDD+GNqiogmPlzK3AIsAY4D8gqnBeRmAsrd+5v4eF17t6/8Y5cjhLgIuCrK1dy8P33s2PmTMp69cjxmSuLOGzIqvrHf30P3/z1PcXr1lUxePBALr/4k3VfuuiiTNF++xV5fT071q4l06dvrrisrCibzfKLX/ycO/7zi8H0BT16sOj44znhhBMpLy/nzmu+xNXAeGA7sAj8C3A87tM78u8iEhVdOZJEyGYZSEOFzqkE+QfACuB1gixkWF0dY+bMYczUqeSmTiU3fz7mDr16UXTMMQ1VOgMGQHU1ZLPkwhFWRd26QXk5RWaE65pTS5C11FJbO5DS0i4lffsyqEcPts2dy9t/eYJ/zprJgrmLuHJtlpd6V7BswHh6DzqLfqdew6ALGip56up28MTLD7J8+WyGAh8kWFZuBjAIOD+835fgUseJBFcmRgE3QxazSbj/u8P+wCIiyfSj4RddRHF5OfsPHsmmJ//IQZ5j8OWf4bV7f8O4z/0HGWDR6tUcN2AAi6tr2L7wbV6tGMIAG8DU+Qv4fH09AL3MmPGreyjq0gUrLeXtD53L+VVVZIDjgQkEfXZfYCiwGHKYjcJ9QVQfXkSkOWvXYv3709oqgDt28Vi//A+5HD2BK4AvbdzI0IcfZtuUKVBSQtn5H67nmPo/ce9/38nmZauL9/nop3jiiecYOXIwZWVFeC5X4nV1uAOZYmo2b2br448XrXz22R23z3ylrPrQQ7n8xzdz4AknMunwwynKZKirq2Py5MnMI1hD/RTgSuDAYAn1H2FWClysPliSRhU8EkvZLL0Iqi7zVToHhA9VE1Tp1AJDgJFLl8LUqWSnTsVfeYXibdsgk4GDD24IdMaOhZqaoFKnNFz4yh2Hd+dLBthIUOXZGygL9+3AfQ733Td2y6y3yt5csaPmr5us15J+o+k98AAGDhxP9+7vfrdRt2MLVavm0WXVXDKr5rFk1TyeWjWXd9a/Qy6X5WDgXILZnR8EPgSU9+/PzDFjGD16DP/4x1OsWLGCcuDTwHdhU3/oCTyC+8fa/y8tIpJQZlcDP6h76eXyuv79i+p6D+eHHzyZYRecxxWf+w8+ct6H+eOfn+DZ22/juEsvo3rhO/TY/2Du+d43uPS/f8jatfDd717Fb397O/sCP//CFzj/Z7cBMO3HN3HN177GWz17Ulpayrp164Dgi+pzwAUEFZkGD+B+cTR/ABGRna1dG4YfwVSPV2ezAHwSmD1wIHOaPt/MZhMUJrYom/UhwBeBz9XU0OtPf2Lr3/9Ot/p6mDBh0/aFC27s+sGFrzH8tA9QfsEFDBm6DyUlwe/mT1Nr16/jnaef5uZnnqm/8867jv3aV7/y40kjR77vtFNOrS0fN64UoGb7dt6ZMYPy56fwwymT+d2MGWzfvv3ddgwG3g98HDgWartAKfAw7hftxZ9MpNNRwCOxkM3SBTiOhgqdowhGK9UACwiqLocAg7duhRdfJDdtGsyYQdHSpcFrDB4cBDrHHQeHHw7du9P4C8QBNyM/WXEdsI1guoR8pdvWbJZZa9ey6J13qF6yBK+upq/nfHxx7bYJ9WXd3p3oeOuWbaxctZ1Vq0pZtQpWr76AU1fOJVu9jF8QzKkzkaASJwO82rUrA0eP5rTRY8iMHcv20WMYNXYsB48eQ9c+fd79O1x44UeZ+dijnAfsA9XXwWcICny+oysQIiJtYPa8H3LIJF6dzYalq3csWrmu7NzzTmfhwkXMnPkauZxz0Lj9WPiHP3DopZeyaWMdbz3zT8YeeSjVuSHMe/VFzv3Y8VS48/lRo7j61dmQybBg7lweP3Yid9fW8uPfP8IRRxzBgQcewME1NZwFVENuKTz6h6CyVH23iHQa7mQ2bmRyXR3HA9/JZvkJ8BbByNKjBw6kJv/cFubdedf48eP5+te/UfPJT34qU19P8TPPUP+HP1CycSOMGsXC007j4blzH/rG+eefa337lr+7Cq075OrqmDNjOg888QTHvP464wfsy+snnMjRp5xKRUUFAJs3b2batKlsnjKFIVMmU/fyy7xaW8vhwLPAdwlCnbOASQTTHgBsAerAz4NpwCXqgyVpFPBIp5TNkiGoaM8HOpMIpqbJAu8QhC+DgX65HMybR27aNIpmzIDZs6G+Hrp2haOOCgKdY46BiopgcuRcDnenPpOhpNFb1hAk+UUA9fVUr1vHW8uXs2b5cmrXr6d8xw6GAWPC5wGwYwcb1q9ny4oldWVLKr3fklWlRatWwdYtOe/Jyg3bmdKrllkZuIUjipxPjhjBK2PG0GfMWEaPHsMBY8dy0Ogx9Bs+nMaWLl1K5fy36Dp/Pv+a/xbPvz2fBfPnM3LxYo7NZqmG2pfgS9Pcf9FB/wlERJLNbJT//vdP+nnn77d5a6a49O6fP/FMF04948ory9etK6a8HH7+0+/x1Wu/zspFSyjtM4gnn3yYc865hM0b6/nLBw5lw4J5TCwqYvzkKQw5+mjq6+u58ogJjHrzTTZdfTU3/+SnfPUrX2bBLbdwBNQNhDuvgK/gXrP7BoqIFJY7h7szY/NmttbW0gf4fDbLYuBJ4OaBA/kK7DrcmTRpEl//+nWcffbZ5HLuL79s9vDDsHIlDBjAyvPPZ9WECRzSpQuZTCYf6jirV8Pf/25Mn/IHrin/J37m2QyaOJFe4XyW7v5uWf22bdsYMKA/27ZtA4JS9s8SzF85AhgAPE1Qcg/BfA3TCYKfM4HNwJ2Q0WpakkQKeKRTCCdGHkdDoHMSDf3ycoIKnQEEC0uxZg3MmAFhlQ7V1cETx40LhlydeGIwBKuoCOrrqSsuJlNU9G51zv9n77zD26rOP/45Gt6yYyd2JrGDswkhBAh7hRBG2YVC2W3ZUKCU0dL+aKGUFtpCgTDKhgZK2RvKJoEwQjZkOrHsDMvbsizbku697++PI8WysR1nOet8nud9JOuuc6/kc8/9nnfYaMcZYjGoq6OuooK1gQBNtbV4wmHyHYehxMUeESQapaKujuCaNVBaSk55OQMCAVyteogeAhYAC1wu5p85tW7ttIOeG90nyzpkXZ/cPdb27VuUWTQsdffhw0lNTUR2QUNDAyXLl2EvX06/5cvYbflyPl++jMtKSljV3Mw+wAnokugKOB2cweD6Dqr+B9c3ivx7K3wVBoPBsEsgQjqwzrIINoclN+uis25g+jMPBUrKlZNTrFpb/cyfP5cTf/QjLCed6U89wnk/u4RAAO679w/E7r+NXwLFv/413r/9HYArr7yC6oce4sBJk7hyxkw+eOcd3jjtVIoh2AT3/wluMZVbDAbD9ogIHqWwRDhahNcbG7FjMTKBM22byWgN5aiBA9U/6RCW5XK5OOWUU7j11tsYO3YPRITlyxVPP03E7ye1f39iF12Ed8wYPTZXCmwbli6FmTPBJzWM3S/KyDG5ZGSkt2uX3drKwu+/Z8bnnzNv3hzmzp1L49KlFNs2u6MFnSHoh4Qc9OxwOjpJ5q3Ae+jqKqDFnf2Bx8FeY6oYGnZSjMBj2GbYNkNonxh5UHxRLdqjJg/dRxOJwLx5MGsW8sUXsHIlCqBvXzj4YDj6aJgwATwebI8Hx+tt552DZUFTE1RWEly9mtqaGpxQiBzbZn1mfxFiloW/vp661auxVq4kq7SUwYEA/WKx9bsqBxbk5fHd6adTfcEFxPbdlz5uNyNhvbXFVDmORXV1PVWV1a98/FHh2u++y8xcvow7li+npbqas4GcnByWFRaxr8dLzdxvEeA5YAIwCl0W/SSIHQgvHw9/QmTxlvsWDAaDYddEhLOBZ8NhLNvmwexsLBG5tjLgqLR0t/r8rpvlhDvuUFWVdRKtrFN2qmB7h1FSspzHTpzAHrEYsTFjuHXuPJTHw4x332XySSdyQ24u18+dR6vj8Ng+E/E0NDTcAgcgsmxbn7PBYDB0hgg/Q+cgPlUpAiIcJsLbwSAey8ItwmmOw9319bUDDzigOKuxMQhAWloa11xzDddddz39+vVDBFativLvf8dYsSKTvfeGn/4UBg/Woo5lQVmZnpgdPJhov35Oitu9PsMB0UiEspUrqZr1BUM+/ojg3Lm8XVLCahEK0bkYCtAu/QmagQCwBj3juh86SecvgbfS0yksLCQUChFbu5ZLgXnAW/CAiFy11S+swbANMAKPodewbfLQJcsTgs7I+KIwEEF753hBJ1UrLdXJkWfNQs2bp71lvF44/HA49lgYMwZyc7HS0nC7XFrwcRydLDkYhIoKwqWlNNfXk2FZZCY1pdlxWBYMUlVeTmT5ctJKShgQCDDCttdXyIq53Szec09Kpk6lZupUYvvsQ5rPR1G83e1jqvR9ZTk6Tnn9q+NQxk03FdEYPH2pyEllGZmTsocOdXuGFjGgsIicoUWk99GOSt9++w0nHL4/56NdlxJ1zzMgOBCePx9uQiS4Rb4Mg8Fg2MUR4SMRJoRC5Hm9HJyezoeRCKU1NTK2wNey2Ftf7ZUBAwrDsdSUZW+96BROOcPV0ODw9JkH45n3FTO8Xqb7A/Trl0NrfS0P7zmOl2tqePq119l96lSeOORglsyZE50Jv5wr8si2Pl+DwWDoChFOBaajJ1lPVIoFIhzgOPwvGCTdtok6DlfGYtZTr7/+PH/+843cffc9nHzyKaSmpuI4sHp1M+++m0p5uZtDD4UjjoCMDD02D4fB44HUVC30xLGx7YD19luDPW+/Tc37/2NxeTmgBZwJ6LHwInTxkUagAqjMyKC+XwEN/Qqo8HpZWVvJsGHDKCoq4pSiYQwoKiK/aBjpRUXkDRgAwJ//fDult/wf/YBH4V/1Ipf12sU1GHoZI/AYthq2TQY6d05C0JmIjjaKoQWddNp0DBobcWbNwvrySzxff40rENA3gyOOgClTYMwYZOBAJCVlfegUzc1QVwdr1xItLUUFg+08d+pFWNzSQnl5Oc2LF+NZsoT8QICRIhTH20J+Pg377MOqgw+m5qCDiI4dS0bfvgxwuSimrVoW6HvLMtpEnOUiLLMsqh2HAqCoC8tud12aQjhlftaW+aku81NV7qe+zE/tqhIqFi0kJb7BkYADzYfDWcDbJk7YYDAYtgzxe0BJJEJjJMJX2dksFOG6qipiHg+pfftyPfD3SIsTs0tKy1VxUXFFhYvoM/fzzp+uYSbwi+ff5oSfHE8wCDeffTyZ777LKTfcwEF33sUHv7yK5x54oOZN+HWtyDPb+HQNBoNhg4jwMXAwOpXB2UrxWizGAcAnjY2kOA7B999/I/eoo07C5xPS0xW27dDSopg5U9HaCvvvLwwerOjs8dJxCLlcLEGnwvmPy8UClHL9TLmiv8nNdS/K70+kXwGV+f3Jyy/gtH4FqP4DiQ4ZSs3AQXj6FpCRnYPXuz4VJm63kJOTpBjFYqwtK6PV76e8zM+npaWUlflp+vZb9l6+nPeg4iuRQT9sncGw82AEHsMWw7bxoj0jE4LOgeiExA5a1EkhLqqAzo2zaBF8+SXer76C776Dfv1g0iQt6uyxB9K/P8oV99xsbYXqalizBgkEUDU1On4X7Zn5vW2zbAql4cUAACAASURBVM0a6hcswDV/PrlVVYwE9gL6pqXB8OGw114E9tuP2n32ITZiBOm5uQxwu8lJOo0YOlR3GXEBR4QKyyIqQjadCzi+DpeiCZ0I2p9kZYCfpiZ/+oDs6SIy9W1wPRnfQPFDfg72UdCcBjci8nCPvgSDwWAwbBARbhfht01NuFwuzs3M5JFolBXV1ezVty+fpqXRz3EY1tyMKy3FWV0RoNhZG2Dw1FHur8NNlBx7Mue99SqhkGLpv+/nvauvZreDD+bCTz5FXnmFR396VvBykVyTb8dgMOwIiKCAM4H7YH36gltWr+YT4NPcXFyRiM5x7DiC4yhycmDVKiEtDYYN0yPZaFR72zsOtLTQ4HKxUITZ0ShljkMmOsKqAJ0ypwDo7zh2gcvl/sFQWERwucDlUigVz92DQ7ixgYqqStauW8PKlSuYM+cr6v1+DistZfa6dbzoOFwY38dTaG+gq4AgRB+Hn9kiz221C2kwbAcYgcewycQTI4+jTdA5nDaxw6KtvDiAAPbatbi+/FJXu5o3T8fk7rWXrnQ1dizk5KzfN9XVUFm53qS1lXWOw0IRvg8GKfv6a5wvviC7tpZRwAS3m7FDhpAyahSMGkVs4kTqx48nNmwY6T4fuUq101HWAstEWC7CasehyXGwRchAh18Vxa2QHwo4IdoLOGW0F3PqMzLo+h9LqSHANSNh3xU6mXSnTIBL5+lEzy8iUtvl/gwGg8HQY0TwAGWWRVpzM40+Hy8AN9TU0AKk5+fzG+DOeBL9D1tamFJfD9nP3P/H6tuunnJ5esYBr66u9mRmpVNaUsJx+44nIyuLD+bNJ9LczBP77Rt9q7Hxl/NMWJbBYNjBECEXuAu4CMBxiK1bh1cE8vN1qJVSukiJ1yvk5ioCAVBK8HgsQqFWfD5fs1JkdHGIKBAVQblceDweUtxuPZmrQ7eE6mpFeTmsXAnl/jKGl91KbWkpb/r9DF6zhqGWRQSYA3yFnlX9OTpx54PovA+noAfx/wSOB/YD5324ylSfNewKGIHHsFHYNkXAlLgdje5PQQs4yQKKA9DSguvbb3W1q5ISyMuD8eNh771h5EgdggUQCkEgAFVVSH09NfX1LGhu5mvbZvHs2QTffJOshgbGAhPy89l7+HB2GzECRo2CsWOJjBtHbMgQ0r3etpAvoFGEZUCZ41DrODSLgAiZ6ITORXHL6nCajWgBp6Nwk7CGbgWcjUAp1eV+RKQzxx6DwWAwbAYinAC82dwMjsMfs7K4IRZjeVUVe+fk8G5mJuMch4KWFgJeL4PWrsUNPF9czDkAn3wyp/aII/bJq6uzmDx5H7777jvefvsdDj/8cA44YH8WLlx4jpgZYoPBsAPR2EiWUvzF4+FopSh2u/G43W3Vrioq9Hr9+umiJSLaS6euTkhNDRMMVtPSEsbt9saKikaViZDp9ZKVnk6m14trvQeO0vsqLdXJlv1+WL2a5ooKAmVl+EtKWNESvvXMPVneZ2/KgVIWs5ajgdXoJEH9gYOAsfG2C3AocBvwRfyzI4DDgMeBXwCzQd4RacvmbDDsxBiBZwfAtklzu2ndRsfOByajK3Yfje5XO0MAJQLLl8PXX2vBJi0N9thDe+n066dXjMW0d04wSDgYpLymhplr1/J+VRUld99NWijEuJwc9hk9mklDhzKmuJiMESO0IDRmDHafPm0ijuMQUwq/CBWOQ4MIURHcImTRJuJkdmhrA12LN/6MDBo2+8L1ECPwGAwGQ+8iwqsiHBMKoXw+Hgauqa2lybbJLCjgT0rxh5YW8HhYVlVFcSRCIzC6uJjqQICzCwrk2cZGxW23Xcc999zD73//e2677U9cfPFFPP7446bvNhgMOwSOQwpwAXCcCCco1VboJOGl4/Ho944DVVV6WVaWEI3qUC0RRV6eWj9hC3o9v18LOGVl2IEAdevWsa68nNIlS1ja0MAqtF5TDqwWIZTcLqXU2cCjwyDjZHReykZ0CfSv0WXPif99GnADMAx4HrgTnWNhAnASUI+u3vIglDeLFG75q2gwbH8YgWc7xnG4SoRa4DFgBvAG8LLbTdXWOqZt40MLOmeiBfCBG9qmrg4WLNAdekqKFmJGjtQxuAD19Ug4TDASYWkwyHvLlvHc5ZfTGIux1377cURREfsPHsyYQYMYMGIEauRIGDpUK/2Jn2c0Sp1SBJSiUQRbhBR0OfJB8AM30Aa6EG+Ast4UcDaEEXgMBoOh9xBhgAhrolGcaJQXfD5OtixKKiuZkJXFm9nZHGbb+KJRvo/F2LNWB8eeV1zM9ECA7JwcqpWSlFmzPmfKlMM58sgjef/9D5g+fToXXngBQI2I5HfbCIPBYNgOcBxcQCWQKUK6bSMul86zo5Qe18di+n3//npcHgzqUucZGdDSokUeyxLq6kK4XN6G1NSMaq+XprQ0wpmZNKWn06wUFjpxc49fP/jg/T2+/PLLo1vD4ZxRjmP1j0a9jmXhODZzLQu/beOzbQ62LKK2jc+yWLlgAU2rVhFEl7bdK77D16BlAVxkPCsNuwpG4NlOcRw8wFKgWIRGtACdjvaU+Qp4CXjV7aZ0c45j26QAJ6MFnYPoIOgkVPzkvy1Lx8VWV+tyh8OH69Ar0J19ZSUtLhfzfT7+09rKC9ddx7ChQ5mSl8f+ffsypn9/BhcVkTZ8uPbwSew3GsWKRgm63YQ8HmJo4aYvOj9aMvV0L+DsMKXElVIWtAsrS2CLiKeTzw0Gg8GwiYhwI3BnUxOkp/OY281FdXWEIhEyBwxgGnB1SwsRjwfWrsUtwkfAccXFSF0dX+Xmsn9lZZiJE0cgIsybN5+amhr2338Szc3NIiYEwGAw7EA4DgPRSZWzgVeUIj/+aBhZuhSamiS1oEARCFiMH69IS3NjWUIkorDtGLGYN+7dU8YeexR+jh7TutF5ODf1dZMmOO+69hpW3n8fg9EPTAei1au/wqVzTE40wy6EEXi2YxwHLzpP2BXAESLr89w46OS7AAuA14BXgYVud/e5YWybLLSYcxowCegXPxaOQzsXS9sGt1uLLzU12jIzdWJkd1ySWLMGp7KSdR4Pr/Xrx5ezZ1MI7J+Vxej8fAYPGUJWXp7eh4jeZ0sLURGiHg/i8ZCWcAlNoo4uxBt2MAFnQyilpgFXdrLoARG5qrfbYzAYDDsrIigRltk2u7W0sMDnY4xtUxYIsGdGBm/36cNUy8LrOPjr6hjS0kIU2KO4GH9lJRfl5/NoMAi33Xbdu/fff99xH3zwIfvttx+TJu3HkiVLwPTbBoNhB8Zx2BcYD/zX5SJ81ln0Kyt7snrSpCouu+yXOI7NoEGp9OmTgohg24ra2mbc7gxs2wFchw4YwOdboB0uOghFe+894cyGQMU9R7ndGYe43YyNZ2ee7/HQ4nbj8ngIrVtHc00NTeiZ4BPRNd/z4XJTjdawK2EEnu0Qx+EC4BB0LrGZLheO4zAWuFyEnylFZvxrE6AGLdIodGLghNgzCy0EjUCLRCcBe1kWWbGYdrNMTW07ZsIFMyHwNDdDYyNkZ2s3TNCJkJcuxa6qYq3Lxcq+fbGzsynKy2NQXh4ZSrUJOa2tIILj9aJcrh8o8bV0VkK8zQOncctcyR0DpdQC9A01wUIR2WtbtcdgMBh2RkQ4DPispQW8Xl7xeDitoYHm5mbSBgzgRaX4SXMztSL0q9KB0NcWF3NvVRV52dlUiuBxuXguNZVznnvuP9/+9Kc/3ef8889j+vTpoO/HDxqBx2Aw7AwopaqJTwIDDBlSxK23TmPy5B/Rp4+uehuLWXg8HurqYoh4cRyaRBg8YMDWGcfHc/PccSoM/SuwO6jXgL+jBZ16dI6GWHz9POAnIO/CE36Ri7ZGmwyG7REj8GyHOA43A78FskQIAh8B09xuPnEcsoBzRLhGKcYkfX0l6H5tL8ArghONomIxXXowPb0t1Coa1Z40KSltnjiWpT9PrOc4sGoVfPcdUl9Ps8+H7L036YWFuJO9cUCLRcnYNvUuFyuV6rSEeFlGRvtkarsyxoPHYDAYegcRnhbh7FCIOp+PVBEqKioYnZ7Oh7m5HBWLoYDWdetwOw7zgIOKi7Hr61mQk8P4UIjq7Gx2Rxdseeexxx7lkksu6XgY03cbDIYdmo7iTjLHHHMq9977LLm5aeTmOjiOg9vtobFRYVmgFMvy8xm9tdt4nFJXHQ133w3etT3bxPTNhl0GI/BspzgOGSKcCzwMOuGZCDHHYXVjI7mRCF+mplKRkcEhKSmMSnjPOI4WaDrmzXGctvKECYFGpE3gaWyEhQt1suRgEPr0gYkTYdy4tmTJCZqbiTY1UW1ZLM/JYVFmJstpL+A09cIl2ikwOXgMBoNh6yNCHxEqYjHSlOJTr5cjQiEijY2kDBzIl0pxUGsrVaEQeU36DjaxuJhFlZVcU1DAPxsaoE8fJgEBYN6CBQv6HnjgAbS2/qDApem7DQbDDk13BUAARo/ek7femkt6ukcKCvSzRTSKEw7jdhxITeWLnBwO6YV2ng3cAfSkOpbpmw27DEbg2c6xbTJiMY5qaeH6sjIOHT9ehzslVZfCsrRQk5LSVnkqOTlyYt3kv2trYdYsmD0byst1Xp0DDoBJk7SgU1WFXVVFfU0NpdEo32Vm8vW++zKrb19WZWQQ7u3rsLNiqmgZDAbD1keEy4EHm5qwMjMJA7UVFeyelsaXeXkcGIlgWxbuykoA/lRczC2VlQzs04c1to3L5eKO1FT+CHwGjBs1aqRvxYoVXRzL9N0Gg2HHZUMCD7DQ75dXgT+43azIz2eE1wvhMJHWVlJFIDubxampHKRU7+TN7M7rKIHpmw27Ckbg2c544AGKPB4Ozc1lcm4uB2VlMTQ7m7RYDG67DVasgLPPhp/9DAoKuhZzkkuM2zYsWQLLl+t8OuPGwZAh2qunogK+/57QjBksmTuXz1esYEZpKd8AgXhSZ8NWxHjwGAwGw9bHcZjrOIy3bZakpDAuHMZqaMAzcCB+oCgWoyUQwGXblAITiouJNDSwPDubEaEQK7KzGQPcCfwaONPlUs9h+m6DwbAT0pPJx7Iy0oHvRWh1u3kkL4+/ZWTgCYeJNjeTohT06UPY4+HnwItK9c4zhRlXGwxtlZgMm4hSappSylJKSfy1LP4+YU58nY7rTUvsw7bZzbY5w7Z59fTTWXTKKTxzyilcOHkyIydNIq24GHbfHZ55Bv79bygthbFj4cgj4f33tYCTEHhsGyIRnTQ5gcejRZ3Jk6GsjJpf/IKXzj+f2xYt4pEBA5g/dSq+229n0jvvcMyKFexrWQyyrN6+kjse3X2nG0FXWf03Otv/FmqPwWAw7FSIMEEp9o5GcXu9FNbX14eDQfGsXbsYl4ui5uaYHQrhtW1SgYuLi4lUVfG7nBxGNDRgZ2dzNHACWtyZphQvsAX7boPBYNheUEqdBEhKSgoXXfSDvMQ1iTeFhbQAVyvFGMfBU1vLkFCIlZmZpGRnazEnGCTTcfgv8LYIw3rpFMy42rDLYzx4NoNuEuT2lIWWJacAq+J/OyK4LKvNA0epttw50OaVs24dPPwwPPmkrnh1zjlwyilw4IG6lHllJXz3Ha1paYTGjSPT5yMj2atHBMtxWKIUn7pcrAAK0JW7DkMLf+XoilyvATPdbnZaySf+PV6GVvxt4OENJWLbksmRO+yrR8ffmu0xGAyGnQnH4X7gymiUqtRU+re0QF0dZGYG8flyiESgokJQSj1YXMyVgQCFeXmUWhbK5eKi1FQ+AeYCK4BDlCICoJR6BLg4fpjN6bs36v5jMBgMWwOl1CHAB8Ciiy++eMy//vVI1jPPPMPFF19ELBarEZH8jtuUlfEGMBkYXVjImmCQ530+zrRtnd9TKcjJIeZyYQG3AncrRazjfrbweST3qw7wkBlXG3YlelXgUUo9gZ4FqxKRcfHP/gacCESBlcDPRKRBKVUELAGWxTf/SkQu67XG9oBu3AA3Zh8PxGJOGLixs+XJ4Ve23ZYUGXTuneXL4dFH4dVXoaEBBgyg6eqrmX3ppbR6PBwNeIDvHYf/hsNkpadzkdtNXnKy5STxKATMVYoQWvAZD6Shy5q/iRZ73ne7admcc96e6K4DB/4PfR06s8vhB+XfYRNdQJVSfuAzEblgY7eNb7/JLqnmAcNgMOysiJAuQqVl4fN4JFxXV5fZ2ppDS0s1w4cPpKkpyrp1FjU1dQwYMCSnuJjGYJDVWVkMCYWYlZPDZOALoBiYqBSliX0rpfqjky5fKSIPbmzbzAOEwWDYXlBKjQNmAlXAIY4jNcDNwO3Ah8CPlfph+fOyMnYHFgOvFRZyFkBdHbdnZ/M7pbTIA5CdTbnLxVDgO+BSpZjVRTu2yJhUKaWARuAJEblmE7Y3oV6GHRcR6TVDe4dMBL5L+mwq4Im/vxO4M/6+KHm97dEA2RKWmpoaePnlV6dbltzY3BxxLEvEskTWrRN57TWR666zZPJkkaKiqBx4YLOce67IzTeLTJsWcr7+WlZWV0tJOCzBp58W2XdfkawskVGjRO67TxpCIVlhWRKwbRHbFrEsmWNZ8odYTN63LLHjn0k4LFJfLxIOix2Lyfo2xGJSb1my2rKkJf5Z2LLkZcuS8yxLcrf1d5D0XUwDrPg1tYBpG1g/J/5btDfhO6vdwPI3gF8ABRvR/gDwr40850zgeOCfG2jPq/H/rYvi/4MDaBN3p3WxTbfXz5gxY8a2tXXX78f7+MPuvvuepx1HpLExYjuOSHOzyJo1Iq2tUYlGHamqiklJichRR50owC9WrKi933FEamulxXEkx3FkmuOIOI6c3MnxC+PH/vlGtlsBY7u5/9jA/oB3W19jY8aM7fwW78vWAuuAouRljiMXOo7EHEfmO44M6mx7v1/+4PeL+P0yOfFZICC3RSL62aOxUaShQSQWk7mOI+XxPvVfjtP+OWJLj0mBhcDrm7Bd/w2Mq2egQ76uAY4GhiTG1R3OpcfPJcaMbUnr/QN2I9wApwLPbmi97cWS/nG3iA0fPlzuuutvctppP5bBgwfLgAFPyrBhn8vYsVEZN05k7NiwFBa+LX37Xi0pKaMS21WLCJYlyrKkbygkB9x8s9y1555SmpUl0r+/WDfdJOGKCi3YWNZ6oUcsS2otS8otS1oTy1pbpW7tWikrLdUCU12dRFtaJJQs+liWWPFX27LkW8uS6yxLBm/D76GrG8Jj8UHyOcAtwDPALPTsRE++k2uBs4EpaG+mAYkBdzffvYMuF594/zlwAzAyqa0/6PCBeuDeDufUbj106NxE4DfAx0Akvrwlfqyu2vN90roJawTmdLOdtRHX3tzAjBkz1qvWTb+/EihN/D1jxkyJxRxpbm61W1pao35/WAKBkCTEnmXLYnLvvc8LIMOGDZdIxJFQyJErr7z6kRkzZlwbfxD5exd98sj43+cktakrwakvcCbwOLC6h/egJuB/6Fn0g4GUDudv+l5jxoxtlqErTy0FGoDxna3jOHKM40jIcaTMcWRsx+V+v6T7/bLS75fFfr+s76fWrJF/NDeLOI6eSA4GRZqbZZVlyYOOI7bjSKXjyE8dRxKTjl2NrXs0Ju3k3N4AFvZw3Vz05OwHdD/5mxjb13Uyrv4aeBLt9bnFhCpjxjbWev+A3Qs8bwLnJq0XBuahy5Ieuq0vVift7WqAuUVs991nSXHxfOnf/07JzJwsSqV0te5UtACRD7gS7cvKkklZWfJiVpbYWVkSGTlSXn3uObnGsuQ+y5JFliWRJLGnowBkhcNSXl4u85ctk4ply0T8fpFAQJobG2VNJCLBjttZllRblrxuWfITy5K0Xrj+mcCYDXTEyVaOFkb+hRZdTt3Um0k33/009OzsBOAP6LwNiWVdef5MQ4s0d25g381J7+cDd6HFp7Tu2hPfpxsYBhwDXAXcB7y3getVgr5JvUxbyNrF6JDK/YCnujumsS3SvyQLcI65tsaMaeum7xbgv8Bvzz333J87jkgk4jj6VWTtWhHLciQSsWXZsib59tta6du3QJRS0+rqovWWJfLSS+/UjRgxQhoagjJ79rctKSkpc7s4znPx19O76YNnA98k/S/XAy+iPSq7vP8AZ8T3uajDPeAj4CvT9xozZmxzDT2O/gpoBQ7rbl3HkYmOIxWOI/WOIz94JvP75UdxL54b4vueBsr65z+fkVBIizytrSKhkEg4LK2lpcHb6+sbFjuOyNy589aMHTt2URf9WsKeQYe07kuS2J10Lp2J8PcCIdp7rSev8zB6IvcNdKoQQeda+xPwbHf9LHqs3x84ArgCuD/eP6/r5hw2SagyZmxjrfcP2IXAA/wOHUqS+CdMBfrG3++DnvHK3tYXrJN2T2PTwnw2aEqlbsp2FtrN8lvgLeBRl+vQaenpX3yWmWlFsrJEMjODH2RkrJns9aY8MHnyZHnqqWckGAyJbYsEgyFpbm6NdfD0kUhEpK5OZM0aia1YIZElS0SWLxcpL5fm+npZHYlIVSwmsQ6CT0U8nOtiy5K9LEs8G3FdFXrGcyJaiLkWuAd4Be15Ut3D63ES2hU+vZvvb5MGyp3cKDrdBu36+ku68ZaJv94aX78776BzgQGb054O23R3rOfQN6vv2XBYWsdt70F7TV2FvnkeC0wCRsS/V/cW/P/bLmexO/mNVgMLurhmCzps29V63V3z5OOcva3P35ixrWnd/T8k1rFt+Ws8PDniONJaVSU14bBY+l5nS0mJyI9/fKENTKuulkcdR6SmRhocR3wtLa2Lw+HmppEjR37WzbESfc+J3fSlgp7tvQU4ILnvo4f3H/QM+6nocNz53bVnW38vxowZ276tw7jJidspPdnWcaTIcWSp40ir48jpHZf7/fK63y9No0aNezLRL7ndbnn55RlSX++IbTsSjWrvyXBY5D//+UhuueVWCQYbnZaWVvvmm3/neL3ersY4gaS/W9ATkHcDPwGe7qJPnBl/7ddNfyvoZ8y/o583VRfXqsdjzJ7cn4wZ25rW61W04smT35J4kuX4ZxegE2odJSLNXWz3KXC9iHzbC83caJRSZwN3AEPRniIq/j5BC5C+lQ5/KDAQHUKUeE1+XwC4oB8pKVfh9V6JUv2w7S+JRu/Ctt8gLS2FE044gXPOOZdjjz2OlJQULMsKu1zuDKV0rjIRKtGziVY0ysiWFgpbWnC3tOiEzwBpabakpbWojAwXGRnpKNUuD3EE7dHyTTQa/Xb69H+XXX31VdLa2joULYIkXhOW2eE8m4GyTuwZNiMRWm8lGVZKbeif7WYR+Ut364lIZ4mdN6dNPU7yqZRKRf+WBqBnLd7sZtchwLeBwzegZ7PrOli3n4lI68a2vSdsyd+BUqoaPaDYGKKAF/077/jb31gi6Lwgz23mfgyG7ZINJcAUwSNCleOQ63bre1RtLVJQgLIsWLOGqAgzgKk+H3vm5rKgtRXcbsalp3Mt2sPmOKV4rwd99zHoUKpO6a7f3sQqjr12jzAYDDsPW2LcJEJftMfLgcCvlOLexLKyMoYBi99664XUq646c31flJqaxuefL2fYsN3w+WzcbjexmOA44lRVKcvrZdrAgapIKU5bvHgxl112KZ9//nm79qEnSoeiUy/sjxbMJ6K92LvCQac3mAR8SRf3DLRHkNOT8+8JJkGzYVuzzQUepdSxaAX2cBGpTlovH/0wZyuldkersHuKSF2vNngrEBeDHgUykj5u7vB38vrk5eVRW1vb2eJOyxZ22N6NDt8aAAxUasDQlJRbj3e7p5zkcu2O4ywnGv0HlvUM0EpeXh6nn346Z599LoceeigAtm3jcrlRClpaWux33nl76UMPPTTLsmKVRx452XPYYccMtO2UY3Jy+g/Izu6PUl5cLsjO1paSImiRSCuLLpcLgMbGRubMmcPs2V8zf/780Jw5c/yrVq0sEZFkAac8/lornfxgd5RKJN11+PHPfy0id/f2jWFThY0NtVMp5QX6AHlJltvh784+y+1ivwla0GLP4C6WC/BXtMgRQbseb+j9r0BXf+jAi+gZnPSNtDO6aX9vUSYiRdu6EQbD1mBD/b4IJwJvOA6OUkhdHWU+H8O8XlR1NS1NTQCM2313SsNhgmlp+Bob+WduLvPQs8F/Vorfx4/VVV+XeHg4HB3+2yv9tnl4MBgMm8KW6jtESEeHMJ0K/AO4USkcpdSoe+997pGTT/7pYeecM4Uvvvho/TZ9++Yze3YZmZnpkpdHxOUizbIQoC4QoK/jUJKXx9ORSM2N/fr18z3++GPcdNNNdl1dXZdj0vg4czw6aqE7zkSH7nZxPr02efqQiFyxJY9lMHRKb7oLAf8BKoAYsAadzKoE7Ro3P24Px9f9MTo0ZAHa6+PEbe3utIWvxdnoZLyJpLxn04WL94EHHiitrTH54IOP7EsuuVQKCgrWh2JsXhs8lsdzhqSnfyNZWSIZGQHxen8nkGehVfFjp0495rrnn//vO2vXVtTqkC0nHn7liG2L/O9/H8jJJ58sbre7XZuHDx8rl19+szz77Gcyd25Ili4VKS8Xqa21JBp1EhW64q+OxGJOcmhXKJ68+UHLklMtS/J7cD2321CdDm3szGXz8fjrFfH1unLB367OqZvz2ax2or3fstHhnBPReYbOAC4Ffgv8LemadWWxDSzfkhYFgmj34VJ0udDeOnZ35mzr34gxY1vLaEtwnAiRbtfvW5Z8Yts670MsJlZ1tcQSOSBKSkRKSuTXIkJtrbzkOCLV1bLOcWQPx5Gw48injtMWUtxNX/dm/HX/rdUfdnHupvqhMWPGNtq6GzNs7L4cR9yOI/c7jsj8+fNnp6WlfQ1Iamqa/dlnJfLhh4ulY7jVQQcdaa1bJ7JunURaWyUU759ty5KSsjJZWVoq4vfLC7GYPOA4YjmOVDmOnJdIwtzNeXWXz0yAG7tbZytd6+TnksR96q5t/RswtmvYNm+AsaQvo4tB24QJez9tWXK7Ih9qIAAAIABJREFUZcmypOpVn1iWXGlZMnBLHM/tPlzS0t4WnaOnJZqVJfdmZUlRYl3bFmXbMsGy5B+WJXVt+Xkcx7ZFmptbqm+++XfSv3//H7RfKSWzZlXvu2SJXLdkiby5ZIk0+v0iNTUira26IlcsJhKLSTi5olcHa7Us8VuWvGdZcptlyeGWJX229Xe2idc8+SYzh6RSu+hSixHgO7ZzwaqT8+nVdm7oZo2eWU9HewQNiF/nUejZnv3QoY1TgB91N+gBJqNdkSfEtx+K9ojLootcQhvYX2+Zf1v/PowZ21oW73siQP+OyxxHBtq2OPH8O05NjXwTjeq8cqtWSXNJiXxbUiKe6mo5JBYTCQbFaW6WYY4ji+NVXX5wX+2k734ZPXst8b5hnw4D+a3aH3bSno+39XdizJix7dvoOmfoBkWOTsZ7bymlXr7xxpssxxGZNevLpqKiot8BA88774o3/X6RSy+94Qci9Lp1ckdFhciaNVIbDkuD4+jnGtuWpWvWyN9KSyVSWirBykr5i23LV/FKhh85jozcQNs6Fb2BGuCh7tbppWv/UPx4J2zr34Gxnd96PUTL0D3dhcvYNgoYh67YcQa6gpSgEzi+BLzsdrN2c47ndk95IT39gxjao0gBLwB/C4WYl9jGcXCLcDhaEZ+iFG4RUApisRivvPIyDz30IDNnzkxs0s71c+lSPGjPjCOByampHJaVRVpmJqSmxjewWaMUc10uougH8yJ0+E5H19II2nNiGdpFcynaK2wlUO12s93+wJVSL6GvwZFoT7Vz0KLDL3JgZINOlu1OMk+Hv5M/2x/tgno5Imt6+VS2CVsyNG9LhzxsYg6eLYnJwWPYaVFK9UF7Ab8kIhd2XG7b3OpycQuA4xAOhfDk5JDa1ESsqgoXsE9ODovS0ginppIWDHJ9375MQPfBU5Ti426OnRE/9ofopP//QSfy/xtwEDBMRIIbcTKpQJRNHIwpnehuIRARkX03ZR8Gg2HnRyl1Frp4RmfhSN2Om7oZbzUD//r440+qjzjiiFvRY/HjlWL1G298s2r48LHDpkwZQ0XFmvXPM4EALhG+AvazbUqzs+mblUU2IEpRVl/P+Y2N/B9wNDBnwADeT03lCvSE3Z+BO5Ui0kUbE88zAFXoUP4v0YVCzol/puK21XJudoZSKi3eltHofItbNe+nYdfGCDw7MLbNWNrEnkTS6lm0iT3lm7pvn4/dgGuAS9DJcj9ED2A/CIXaRBPHIU2Eq4GrQQYrpXAcB5fLxbJly7jvvnt59dVXHgkEApd2daylS0lBJ0A7MiWF4zMz2TczE096PCW1ZVFvWXzodvOw10sJcBxwGHrWtIguchcBYWA5WvBJiD6J9xVuN5ufUE2pdHSlqRR0icRKeibIuD+C0a/DNRPh3e/huIPgtTlwUjHM+Rm8sxGt8ADnob1/7kXkus0+rx2ELZUYeWvkcdpIkSeRyyNBDH1Ors5X/wFC26CtBrjGiDuGnRWl1K/RFU8misi85GUiKMehWin6AjQ08EF2NkcrBX4/AH8pLubm+jr5pE+uOqKm2l7ezx28j7y8adTW/kXl9/sn7fvuH7w/DX5VAWfvBQ8sgauPhVs+htsmwFN/0549nW7XyftU4AR0rrITNlWcV0pdiZ6d3k+200IUBoNh26GUOh54Hf2MsBi4mB6Mm+IC8l5ob/POxiPrJ8FEOAoteoeA48rLCQFLgDcLC/lJ8kaBALuJsESEDMdhfmYmI7OzSddFXQiIcHB5OfujK7IWeDw8OWgQfZTix2gR6TKl+LSb8z0TeB49Eb1f/BzuRpdF/8F9o7dQSv0bXQ23I9tVzlDDjo8ReHYSbJvR6LxFZ6A7MoCvaRN7Sjdlvz4fOejcJ9eiq3ItQA+s/xsKEevQhr0XL/7+zdGjRw92u9ucIUSIKMVzwD0uF4s2dMylS0kDDkxJ4cTMTE5KT2f3jAxdkMu2iUUiLIzFeCEa5aEBAwjZNoOBfdEZ9Q+Nn39WfHcOOkdKCu1vTi3AKtoEn2QBaLXbjdWjC6TUSGAGuqrU9+ikczbafdXuYO0+c8A+H/7hgDTCbjkwtxb2/D2ce4gWirrcNukzD/BHtJdTKnDKruLBs6XZ2tXUlFIL0OFhHXkAPehKrsJ3sxFoDIb2dPgfFeDBjv+jjsORCQ8cEapaWsjNyMBbU0NrYyOrgb1yc5makyOvNQVtfOef8j/1yqtTKFnhZ/z4Z5Vtb3BQVA65T8LV+bCiCkbkgr8BCq6DO3363tKxz7Y6+UzQ5X33Q88y34PIDZt4XXKAdcBzInLxpuzDYDDsnCilDgXeRws7k3viYaiUGof2Cv8JOt9Zl0hSgmIRxgPvosfgp5SXczDwJ2BqYSEfJG8XCHA28KxtI8CXaWnsk5ODcrlIUYp64ICyMiqB29ETcIE+fXgqO5uzlGIYOhn+9UpR00n7FfAqusLhdOB8tPdMf2CsbKOHX5Mg39BbGIFnJ8S2GYEWe05H5wUAHb70EvCS283Kjd2nz0cqOmzrerQ7+mq0sv5YKESow/HzgZvR3j8ZSkEihAsdQvUX4Pl4+NUGWbqUrNRUpmZmcmFaGgenp5PncoFtQ2srla2tfNbUxGPRKJ+NHk00Hsq2O3rgnLCJtJWebgWq0WEsaejS3ylJh4yhk+Ume/wkzO92J7Vb30QeA45Hi18XI7K6J+cV39ymvfDkiEh3FaTabQzcFT+/JcB3iDzQ02Mbep+tLSIZDDsrPfWys20+VYrDRSAU4j2fj2MdBykvRwFHDBrEF45DS0qKeGIX/IL0P/3eJj8/xAUXnKZee7WWnokzVgY0WqASCSnY+L77NvSExGq0u/71myPOK6W+A/ZIXAZM32Iw7PIopSYCn6AL3BwqSdWKO1l3NFrQORM9zneAT9HVpx6kh8KECEPRIs8I2+aitWu5Bd1/ji8sbD/uDwT4jwg/sW1cLhcfeb0ckZNDk9dLDjr860ClWOj3sy/wL2CiUnw4aBAlHg8XoQtcXA88rVT7lAxKqUHoidcc2oelWSLiTVrRhY4EyEyyrPjrwfHrcTEiX3R17XqKUqrLh27ZwpW8DLs2RuDZybFtdqdN7JkU/3gebWLP8o3Zn8+HCx0idSM6TKoBnTjsvlCIQIdjZwA/Q1c+Ggw4Sq0XM1rRrpy/d7k2zrto7VoK0tK4MiWF01JTGe1243EcaGnBbmlhaTjMK9EobwFzR4/Wnji2jRuds2hf2kSfvWgTduqAFej43ITHz27AcNq8gUDf8MpJ8vpRd/x5pPrqyygzZ4xQoVATcDUiG8yFpJSKoT1wOtL+5tP1Dq5Hu/e/iL7JpSPy6Aa3MxgMhh2Mnsx8itBHhDqlULbNqliMorQ0XOvW4bS28lhxMZc2NDAvJ4cJNSvrv+u39IuhHHucj1NOnq3efvsaRL7qYVs2t+++Eu1t+x56kuGDzXl42BohpgaDYcdGKTUKmIn2KjxEOpl8VEoNp03UGY/Wq2ei82++LCKB+Hob1ceIkAu8BhwWDPJYMMhFwG8KC7kzeb1AgFxgkQiplkU/j4d3PB6O9/koS02lED0eP0opPvf7cQNXoPPwpKSn81h+PnsrxUHAZ+iwraXxE0sBMneD6gxwJys28ff2U3B1/M8MOs9LBPoZZgjwbzrJ97axGA8eQ29hBJ5dCNumkDax58D4x4vQAsFLbjdLNmZ/Ph/7AzcAp6G9Xp4B/hEKxTvYtuN64se9Ee1JEwG8SWLPSrQ30EMu18blxbFt3JEIx4lwidfL4W432SLQ2grhMK3hMF9Eo7wDfAwsHD26bf+2TSqwJ+09fcbS5lGzBpiN9o6pRN9oBqFFn+L4a167BtXURFi3LkRh4Qfk5CwiyQvI7aYxedXNUvKVOgcdQz0D+AP6JmQj8nS32xkMBsMOSE/6S8viT243v48L/l9lZHBAJIKzbh2VwNi+fTnD5+ORUIhodmvVLap/wV+ZOeMRdfjhuehZ3v9D5Jst0ZZuNv4x8Ev0veU24NfAW2xG7hzz0GAwGJJRSg1FF2BJRXvuLE9aNgwtMJ+JHpODDhN/AZ24vtMJyo31QBYhDR1G9ZNAgJXRKAOB0YWFtBOaAgGOAj50HBbZNnt6vbzpdnNiZibfpKXJJKWUg22frrye94HM4GU3DQtedN0fnb4Fx6pw05qChmVz0vYZNwWPJ4133/2Q88+bpRoaXAB/1OPj9UTQyTnDwONwVtKfCWtKen8F+tklDbgWkRldXvAeYsR4Q29hBJ5dFNtmN7QwczraBVGh43NfRHv3fN/TClQ+HyOA64AL0R3h6+jKW+1mJOOhU0eihZ5j0F48LUBuPHwrhk5Y/DuXi7mbcE4K2MuyOEcpznC7KQSIRKCpCcJhgpEIH6PFnk+AxaNHtz9H2yYT2Jv2os/wpFVK0APzhPnVdb86l912Gym/um4Vq1cfQH3dwew2NJ3c3NQOTawmKdfPeeed88eVK0tYuXIltbW17Vbs9iFBqSlor6ilaG8hG6UuBUKYvC0Gg2EnpCcihm0TcrnIsiyWOA5jvF5YuxaiUU4bNIgPRWjweHA1NXFlbh/5J98tKmX//X+uWltXoZPkZwG/Q2TOBtqyaQKPzoXxB8CPHuRnocWelxHZYH66Ld4eg8Gw06GUKkB74fQHjhCR+Uqp3WgTdRLe/N+gRZ0XRWSTi7J0hwgu4O+Wxa/WrcMGXi8s5Mcd1wsEuAe41rKYIcJhKSm843JxfNbHr7emnX5iGkrBww+9o668cnZim8YLry5uuPr/jndy++Wlrvp+bsFAj+0aPWo/mprW8txzf1OXXTpjJMxNKDbN0C655gb66oPQuX8WoD3k30Bko59LOt91O6EsUWDjShF5cEvs32AAI/AYANtmEG1iz2FosWcp8TAuYGFPxB6fjwL0oPUqtGfLl+jKW6+HQu09c2ybvdDeP2ehXUJLgYFKrQ+HqgaeAP7hctFlzPAGzmt34BTH4Uyl2E8pVCyG1dSEp6lJ5+9BxxcnBJ+SjoJPfD+5tA/t2hftsgngEAyW8/13NRx08OPAbNeQQekqUPF/ktc37Dzz7/s59rg82nv9DEeHf62noaGBa675Jc8+Ox3o5saj1F7ovDvVwKWIhOOf/xKoQOSlTblWBoPBsD2jlHoAPaPakQdE5CrL4nC3m08dB1pbWZeezqBwGKmq4pXiYk5vaKA0J4eiqir+V1DAaEQUI4Y/q1at+hiRD1FKVyHU7vq/QWRBN20RgMGDB3Peeefx17/+df2ybvruscA/gEbgMkTq0TkiLgH+g8iyTbsyxoPHYNjV6aREuIUe0xeiRZ2D4p/PRYs6L4jIJhVf2RRE+FUwyN3BIHg8nD54MC8nLw8ESAPmiJBrWawADs5c8EWzvf/Bvqyn7g+n/eqKNFwuN/7SJ1Rx8e3EvW1Wf71O7IKBvwV+AzRnZ/N0nz4crxTDgen9+xecW13d+SNEN311DtrzyAJ+AfwK+AiRmVvmaiQfSil01dwj0NW9NiqSwmDoCiPwGNph2wwATkXfGI5AK8sltHn2zNuQ2OPzkYkOGboOGIYuVf4P4JlQiNYOxytEd54XowfW36BnNUcnhXAtQIdwveRyEd7E8+oPnAicKsIUpUixbSLhMHYoREZLC4iwljax55PRo/F3s7+BJESfysqpZGWNJzMzXtidKMHgSvXeu1ksXFghhxzya447/ku3Gztp+7Q99xwbKi4u9hQXD6e4eDjPPTedr776CrrK46BUIboUrg1cjkhF0rJfAyWIvL4p18dgMBi2Z5RSR6D75sSMZ7sQAdtmpcvF7pEIZS4XhR4PrF5NyLIY1a8fl/p8/CEYJJyTw0dKcRxwqHKpg4GV6/tN3cf+Ex3WcAMi33fRltjo0aM97733P/r06cPee0+gtLQUuu67B6Jz1bmBqxApi38+DLgAeAoR/2ZcG+P2bzDsonTz/y/oCdtF6ETJL4jIit5sWzKWxdmVlUwXIZafz7jUVNq1JRBgAvCNCO9YFkNwnD0yl88Ve/zE9Kz7bl+cduvvhuF2p6OfR85Sqm3i2O9nFDoR9GSlmD1wIPO9Xi6sq6vz3nTTjTzxxBN0eN7tqq9W6InpvYEbEZmDUr8F5iHy3pa+JvFDDgAWAmuBA0QksjWOY9i1MAKPoUvi1bASYs9k9OB0FW2ePd92J/b4fHjQnkE3oqt5VaLd4B8KhajrcKw84HLgGiAfPctQBhymFH3jq8XQSvfDwIcuVw9Lmf/wvLKBY9Fiz4+UwidCpKWFqsZGcsJhsh192yhFP1B8jBZ81nW6Q6UmilInOW++/QrHHjeahJePZU3C48kAQJwmlGsu7cO7Sj0eFaV9ss6ubjq58fPOBn6FyNIOy38DLEDk3U25JgaDwbA9o5R6Cn0/GigizcnLbBufUjTG86/F0tPxBoNQV8fFQ4bwvuPgd7lQsRh3Z2ZyHXCNUtyHUpcBQUT+k3SgIrQnjwct8izu2BYRDqqrq/siGo1y/PHHMX/+fOi6785EV3/JRz8wLEhaNhrtxfqvdoL9pl2fjjP474rI8ZuzT4PBsP3TjQefA4zbnrxCamq4IRzmrpwcQjk5HKYU85OXBwLcBPxVhKssi2tobR2c3lpfJ337DfL95opFqY9MG0ZqajZ6MvgopWhKbOv3o9DVfu8G+qWmMr1/f4YrxUEzZ87k8ssvY/HixdBdMnylzkCLZS8hMi3+2dXAWkRe7nSbLYBS6gTgTeDvInLD1jqOYdfBCDyGHmHb9AVOQYs9U9CD3zLaxJ5v3O7OEyT7fLo8LVroORbtWvkYcE8oRFmH46QD56PLHg5H56t5A9hHKQ6lLdN9EJ3UeTow2+XqWb6gTs4rFZ0X6FTgZKC/CFYsxopQiEgwSJFt0ye++nLaPHw+HT2aKgB0pYKfAo8mV8+ybVzqumvPQamb5OBDvJxwYoiUlHHo2WHQlbu+feON11OefPKJI5YsWfLmihXLT/pBI5VKBR4AioA/IvJ5J+vcAnyByEebch0MBoNhe0Up5QMCwLMicknH5ZbFDLebQ6NRmlwuslwuWL2a2T4f+3u9VPl89Kuu5t38fKaiK7ucoRSCUucDKYg81uGAxWivUQX8mqQEpSKchJ4NXz127JjI0qVLx6GTmHbWL7uB+9AVHO9A5MMOy/dC33vuQ6TuB9tvAkof0w8sFJEfbYl9GgyG7ZcdLQfX6tV8IMJRAwfS7PFwqlJ8kFgWCOBGj7En2DbHO80tbygr5k7tk1GJFRuWc8mZC73PT9+N7Ox8dEXbQ5WiXf4gv59c4A7gUmBdv368HonUXe7z+ZTX670DuF0pWn7QMC3uP4z2pLkEETv++S+AGCLPbPmrkXx49SB6ovto6XivMBg2EiPwGDaaeE6ak9AJ26YCXnTFqZfRrpNfdiP2jEeLNz9FD57/i07I3E7Fj5c1Pxm4CZ0Qrpr/Z++8w6so2j58P7snhRQIPdSgFHl9BQFRQMSChaaiIio2QMVPsPdeXuwdxIYFsIMKoqggiAU7YkMRURACUUogBE7qydl9vj9mAyEkEJBAgnNf1157smVmzhFnZ3/zzO+BCQAinM+W2av+xIg9rzgOi//B93KArpgB98lAS1VUlZ9zc1melUViJEJnIDm45Rfg47jffvypyaWntInNWDquTB8FkaOAm4A12vPoK/2ZHzZls5fPwb7vt3Mcp3g52t+UjPIJh+e5tWveGFz/GKpTyijfBW4FPtoVLv8Wi8VSlRCRoRhPtkNV9auS51QJqVIEkJ8PCQmQlYWfnU3bBg24LjGRC7KzyU5JIVeEAsxkwYag4AFAE1QfK6PSNpilxQpchepiVS7ARON8B/RzHJkGdAH6aOnwfRPq/z+Mr92zqL5SRh2HAH2BBzf5qe0CRORujCdFU/2HkUEWi6VqU908uNLTSQN+i4+nsEEDEoHzRdgknqxaRQvMkqUf4h574KmcoZdOICbmr/gaTozk5dSrNajvr6G33mxEw4aNEdkI9BLh69L1LFtGF4xg0+GZZ+7f2Lp1w5pDhgwB884wXISZmy424+jngFSMR1p6iXNnALVRfWpX/xYlEZEEzLOlJtBeVddt5xaLpVyswGP5R3getTDeNgMxmbHigJVsFnu+KOk9U0xyMs0wy7H+D+O58yFm3euscHhzNE6QGasHJvqnH8YIfzzwswiDgCPYvM4YTNjmy8AkxwkibHbuewnwX4zQcxJBKklVFkQifJOVRV5ODvsBhwE1UEXyc3/ThKT3MLMPn7VtWyItukhPjMizCrgU1fXFpxo3bnxeixYtnj/uuN5/3HrrbXMxYk6bTff+lVFAVtYC2rV/DSP8fO+6m8NSEamBEcJmoLrVQ85isViqMyIyB2gA/EdLDVo8j0mOw2mRCL7r4qhCRgZPNWnCc75PcTasOXFxdAG6ifBDiYL7AB1QvbecitsCD6mIx9Jli2ne/CrgA+BUEXJE5FOMgDNQSxvciwzHmJu+i+pD5ZTfAzgauAvVnVpyXHax0gZYBFynqg/uqnItFkvVozp6cKWncxNwd926/JiYSAfgZuBeETP+X7XKeJM5a1aNTLj75mbrH3j2THGdRbGx2tjJXh+TctLhv7lvT21Mq1bNMGbI54rwWul6li0jBFzcvXvaBX//vfyAsWOfuWTYsGGXYcbYrwFXibAKkSswY/1RqE7dohCRE4D9yu3HdyEi0hH4BngXGFD6eWexVBQr8Fh2GYG3TT+M2NMHkzJ9NTAFI/Z85rpb+uYkJ5OCEXkuBxphDJUfBF4Ph82sbInyD8BE/5yFEXReB94Q4QiMqXNNTOr1eIwB5yyM2PO245QQRHbuu6VhOv+TMAN6B1iuyjsb1kaWFEycelJel541vdr1/gvEBvXPA95t25a7ABA5DiNU/Y0ReTaYw9IXeA/4WlW7BfWlyO23Xk9S0mna85hCOnVKRKR50Bwf6O+6vBuUWxNjaD1te+l9LRaLpTohIq2AP4AbVfW+kudUiVMlH5CCAqhRA9aupTA2ltoirElOJmndOr6oW5fuwEUijC1V+OEYf7k7N4XjA5EIPYAvY2PxtHbtdowd+y4DT2vO+vVTqF37DBHzbBKRWZgly0NU9YUS5Z4CXIYR5K9TXwUYAOwnEjwPzHVHA92D+nfpYExEvgBSMB4cdqBnsezFlPLg2sKAviqSnk4cxvyZpk35znE4AxNtc4kI3qpVCPAGqiemXHDqk3ndj8nJPWf4DY7D3JgYPcBZl5lbu9chfzpTpzShY6e0oNg7gTtKmi8XIyJTMasCrvV9HYOJcLwJyOezz57iqCO7iO/PRfWGrRprJmh7ACN3dT9dFiJyDeY96AJVfb6y67PsnTjbv8RiqRiuy0bX5TXX5RSMoeTpwBxMlpCPgL89j7GexzGeZ4yFw2Gyw2Hux2TbOg8jjrwMLE5O5ork5E1p03FdfnFdhgTXjgKOB6aosr8qZ6kyDJPeHcwDrntQ1mrf5xXfp4/vs1Phqq5Luusy2nU5CmgYtPVHES5IqR/7aOr5xx+8b0rW2n335exQiD7AvUEbDt5UiOpM4CGgMTAa4ysBUBzNE7epvpAc7Nx9VxfnxhtmuF06t3NDkoYJHT0e8xAruaQtNthHdua7WSwWSxVmMEbUfqn0CVXGAuJ5EBsLkQjk5XGD4zA5OZmkrCzW1a1LN+BV4Jkyyi42a04oPhCJcCnwKXCZKvFkrb+Dgac1Z9y4pdSriziSWuL+4mwnm55TiByGSee+WLt2u1V9PRWz3OB14DTVTf01mD6/sJJeGsYD+1PyGWSxWPZKVPUSVQ2pqgT7KivuAKSlUQhcCrTOyOAX4H6MQDVFlYTUVBS4CJF1Gx5+dkDKg7dkAsN8n25FRfKtX7dBnez3vqzvH3NsOp99tiwo9lbgdVUSy6iy2Gi6vQiFIvwPaE9R0U/06HED8+cfqN9991Y5zc3FTCrXKOf8ruYRzDvTY0E0psWyw1iBx1IpuC45rsvrrstpmND6U4HZmOibWcAqz+M5z6O35xETDlMYDjMeOACz5CsdY3K5PDmZu5OTSS1Rdobrcg3QHKPCt8O4z49Q5QFVDsN4+xQLJtkYz6D3gb99nzG+TxffZ6fM51yXta7LeNelP0bIOpXffltAixaHui6v77MPk1u3Zv/WrXm6ZUuGbHGz8Wl4BGgGPBaIPMXmmqa9JkTzWkykz3XFM8uuy2rX5T3X5Q7XJaNEqVbgsVgsex2BYfBgYKaWMLAHUKUmcI4I+D64LmRnE05N5c/YWPoUFKDJyXgYc/z/Kw79L0WxwJMYiSCRCHdiTJHfcV1eA2ZiMkFeKRecf6qoJgKPItIkuK+g+P6gwW2Bm9Vx1+myZZ/z5ZfzMMKOg/Gd6yiyRT9tBJ7K4Q0gH0o9gywWi6UKkJbGB5gI/5uXL+dJ4BLM+H+2KvVSU1kLDNWUOk2zH3/pjGbNZSJwg+/TMxplltewcavsj3+soX16L2HGjGLPnAHAHFWalKpubrDft/iACIuIj/uKK69YSOs2Dh07fa7K/WUIRMX+aGUJR7scVfUxyWYKgVdEpOyMXxbLNrACj6XScV1yXZfJrssg2JR6fQZwGjAdWO15jPc8+mZnEwqHeTcc5nCgG8bP5kYgPTmZZ5KT2a9Eudmuy/2Y7FIXYGZhXwVeVuVbVdpgvGkimBnW9Riz5mHA18Afvs//fJ+dVsgDIWuye8hBTzkN6l6BMZ2egDFrftFxWON5zPI8Lva84IGj+j4mAqk5MHrY5peMGETSgJGYB8rVFTTeLO78i7Z5lcVisVQvemLE8PFlnBsPOL4PoZAxWPZ9botEeDMmBvLzWRoTQzImY1Z5S3RzAbRevSTM8oBbgOdDIS53HGZh+vFBIoxC9fvgfBIwCpGGbBZnEhBJVce5V0dcXJ/c3A40TxvPZmGnnQgTRbbyo6s0gUfNEuAppv0SXxl1WCwWyz/kymBWohdEAAAgAElEQVT/qAhPYASaDsCXqrRMTWWGs3bNi5Gj+3Zd/+K004AHgEc9j36ex9t+42YHr/98YZGeeMJCpkwuFnnaAd+q0rlEPcUJSDZHYIqcIqpdZfToZ4iJaYVJ1nId8Isq9Urcu1sFHoBgQmMYJhnLHburXsvegxV4LLsV1yXfdZnqupyNiew5ERN9czLGh2aN5/Gi53FidjY/hsPGtwCTQeVcYGFyMlOTk+leosxC1+V5TDj6SZgUh48B36uSqEpXjDfQl5h0tSGMU/0GTEjnIt9nru9zue/TcCe/Wo7k5MS7LrNcl4sxLyVdMUuymgGPAxmexzeex41eVP8ARgMtxsIdCUBd4x30QNC+G1FdXcG6bQSPxWLZGxmCicB8p+RBVZr4PieDid5xHNi4kQ1JSQxOSiJm/XrW167NvphMKb9so/w8rVUrVPTTwqeBC4F7QiEeFuEzIA3oI8LEEhXPwwy2awKPtQgOp7pukl5xxev8/scxPP74QcTFeWxb2CmmMiN4wIhgKRjvCYvFYqlSpKWxHGM7cEp6Or1FeAvja1YXI/J0jv14xmXO2jVrC3sc/WBMDCkYL86Xo1FO8jze9ps2773+m8Wr9bTT5vPKy+mYSc9k4DNVTgMokZGqNkAwmToMWAqMEWFdkKH3CGCyCGtLNHO3CzwAqjoZeB64UYxfnMVSYazAY9ljuC4Frss012UwRuzph5lxPB54GyP2vJKdzQHZ2VyFiXi5C2N29nlyMl8kJ3NScrL5d+y6+K7L267LYZjsVp8BtwHLVDlelcuBlhjRpQUmM9afQV1xmKiav3yfGb7POb5fwldh++TCFn5Bvuvyjetyo+vSFiM+3YRZx3sPsNCL6v3eZ1+up+fR7UeLMNo80OpiMqr8VlYl5RATlGsFHovFslcgIimY5VGvqmpBqdMvqJpE5I4DubkQH88nsbF0yM9Ha9YkBRgnwgtbl7yZ6NPPuUVffns29eodDVweE8N7InyBEc2PEGH2VjeZTIV3ArVfdJyDzx84kD9+/fUSHnm0B/XrZwFnsH1hp5jKFng+BlZgl2lZLJaqyyOYpbRj0tOJC/rg7pjo9k9qXXLuoUn33vQMsXF1gCeaNcPH+GBOLypiPjDGb5Y2eP28pT9z7rlzeeaZZZjxeBiYpMptqggm425ikBL9Nsy4+X8lDfZFmCPCNaXat0cEnoArgCXAS8Ez0WKpEDaLlqXK4XnEYELzT8VE9tTFdLDvAm/efjufjB7NIEzmqBaYdLAPAy+FwxSUKqstRu0/BxMZMxl4UISfg/JHYJaC5WMiiDZg0ta2CI5NBV4BZjrONpZAiUzChJZ+CKzBiKcS7Etuom3aJOiZZzXW3n0b0bFjXVxXvIwMeGasxt5z13xM5jFgk2dEefvizwdiwk4voGQmF4vFYqmmiMiFwFjgYDWRMwCocoDvm+wr5jrIzCQvIYH4xEScjRvJqVWLpUBXkU3LX7ciEqERqtPxvPbO6Ecmui33+Y5TTrmbgoK1DL/oRnn55XUY8TwUbJs+aygUy1VXn1g0dOgxoTb7ubrwV3WeevJHnn12kkQixf1z8QtFWV5vxefOx0QDHU+J77grEZE7MZMLzUv7GFksFktVID2d44APgFvS0rgbQJVUjHdme6ZOHbNhTeEBBf1PPwY4MzWV11asINSsGdHMTBxMQpVBzt8Zl9Xt0KyTPvzI4Vx55b4YP880YGJiYsKA/Px8V03W3lOBx1F9c7uNE3Ew0f5zUP24Er7+dqqXQzC2EmCeHVU+S5plz2MFHkuVJsi2dSSmMy7OzpUHvJ+by5QDDyRm7Voux0TjrMYszXoqHN6Umaq4nEaYtLXDgVqYmc0HgA9E6BAcPwvj4/M1xgg6FSPa1AHWYoybXwG+dpxShp0i+ZglVpHg/iJM5hcN9iW3Tce0UeOQnn12w4JDunSNW/gr7m23LmPLjpxSn0vvG2CWgsUCC1A9YLs/qsVisVRxROQrTJh9u5JpvlX5IRKhQ2wsqEJuLqpKODmZmllZ5NWpgw90FmFReWVHIrQCZqLaIHRSP5GmTeJ56mmH334L06f3z5KRUaaYr64LF1xQX2+6eR9t0qyGeh7iukivY3Fmf7iazVkcK0ItTFKBEDAX1S47cG+F2VaaeYvFYqkqpKfzBiaS/z9paaQDqJIMvAkcx5tvzll9yPFJxMXvC7RPTWVF8b2ZmcRi7B6Okax1p9drW+8Ivfvuvtx4076o/orIf+bNm+fffOIJ7sxVqz4CvsckManYS7DItcBCVN/dpV+6QlXL48DFZZx6woo8lvKwAo+l2uB5uMDhGLFnACZdeYHvM/2BB/j14YfpUlTEMZhon2eBUeEw6aXKqIlZd3sl0AT4GXgQmChCIiZjywigDbAO42GwCDgW4xcUj1nW9QrwiuMELxEi4zGm0dMwD443UF1a0e/WSkTvhsjp8F9UF2/3BpEaGMGrNWY52iHA+ai+UdE6LRaLpSoiIv8BfgWuUdWHi4+r0tPzmF1srKyKhsNoQgJOURF+XByO63KmCK+VV3YkQieMub+L7/eNufuOLxk50mXWLI+zzxotmZnpQLTkpvHxUX3q6a6cOvBMrZFQFwDf9xd/8cXSSbff0rLPZ5+tOtgMtDPYUpgvPcBSguVfmCjRQzHPsd6VFcEDICJzMJMB/1E76LNYLFWQ9HSaYUTyD9LSOKX4uCox5OdPoEaNM/2Mv2dnxjTuCnwDHJuail98XWYmSZhsve3Jz+tTPy3xGL3lltMYeWdrfP/H/IKCAzUrS2qce+6nzicfn4yZLHYxInvxvuTnBKARZrL3BqAx0Ksy++qyEJFo0KbSeKoa2p1tsVQfrMBjqZYEYs+hwECM2NMYKPzyS766+mpiFi6kC2agPQl4MBzmx1L3x2JMMK8F/ovxKXgUeC7IuNITE9VzEmZp1XSM2JOEifTpGRz/DnhZOrRvID//fCjGTDkVs6zsI+DziswQiIgCuaq6fd8fkQYYn4daQbtODH6LWwJ/CIvFYqmWBLOVIygViq6Ko0pGQQGN4uPN0qycHKIihGrUMD48yck8JcKI8sqOROiJWXa7HugdQ9HlxMT8H6+8EuXCYaMkPz8X+Ar4EFVPFVeVS1W5BdOng4kUfQQYHwrJaZg+/11VPaECX64epu+ug4kivRNYiurQnfqxKoiInIcx6+ym9hlhsViqKOnp3ADcC/RNS2N68XFVhIcfWsfV19T2lizduC55n5rx4574pNZNl8zFRM4XAYXR1m1js6d9frEmJtVMvvy8R+KnvPofHTHiMB4b0yD3h++9uIaprlOvnuf8739vy/33LcP4oMWWsy/OUJsMtKeSoy3LI3g/KBNVLWsJsMViBR5L9cfzcDDLlAZionuaZmRQdOedrJg8mcbRKPGYJVcPAh+Gw5tnVYN7+2CEniMwGVueBMa4Lqt8nyaYiJ8LMUr+Mkw63XcxKdHPBjrh+8rcb7JZvORVata8zTm5f09M+P3vwFuo5pfXfhH5CfPwKGa+qh5YzsX/wfgSRYDXUV2OyL1AR2AUqjMq/stZLBZL1WFboei+r99HozzveRAXB75PUV4eMUlJkJVFtE4d5gPdRShtyAxAJMKpmMjLP0Q4MRTiQeAUXnpxEUOGLBUj0BwHHOLXr79SF/95IIlJgzGzuGCWzt4GzHZdM2ssIkMxGR5nqmqv7Xy5tpi+Owq8gYk0fQOzfGo4qtGK/1I7hogkYyJSQ1gPB4vFUkVJTycWmI/pqw5ISyvRn4sU6YUXhnjiSaIb87z1ebFOSv8jvov9/pvckmVEW7aJy35nTkfckKScdOTc0G+/1NDBg1vqqNEpK844nYZ331MY16lTHA8/tJTrrlsu5j1YMePqCMZ/MyvY6mMyEbbDTN4ej+rnlf9LbMZG8Fh2BivwWPYqAsHmYIzQMzA7m7Rx4/DHjKFo/XriQiF+jka5D3g9HCZa6t4uGKHnFMxswAvAw67LIt8nBpNqdgRwFOYhMAkjBmUz/f1HaX/gkTRpEg/ko/oOkyfPlfOG1JTc3GyMGPN36faWIe4Us6XIIyIYL6IjMGngJ6G6MTg3GpMd7GVUJ25VksVisVQDyhvIxsfHe7m5+ZHcXGrUqAGuCwUFFIVCxBQWovHxbHRdOonwZ1nlRiIMB54AvnIcznJdXgAOZ9myO2TffVoDqage43m0IitrLCkpR+I4DqpRRN4ErnJdVpbR3mUYA89ithbnjUHnkZjlxX9j+u4NGG+c54CFwK2orqWSsB4OFoulupCezrHATODWtDTu2nRCZBrQUy+44Dt9/IluvoSc7JX5y2t3aTPMXf13DEaMTwASC3uf2GLj2Ncuk/y8gpR+h70WWrLoBK1Tp9mCrCxejI/npOeep9uZZ8LKle9z5qCL5dNPV5TMpoVIbeB0jKjzCWYytwlwLaq/7KafImiK7b8tO4Gq2s1ue+UWjapEo9o5GtX7cnJ0yfjxqh07qiYlqaam6tpWrfTmpCRNKuO+1tGoPh2NakE0qn40qlOiUe1afN7zdH/P0zGepxs9T9Xz9Hvv6bGveLVqfeIPPe9Jz9MnPE/Xep6qF4lmeZ/M+dwfMuRZPxTqrIGoWrxhZg3K3DZdB/EKZyrcodBfIbRFm+F5hakKF+3p39xudrOb3XZ2K68vHDNmjObnq+bkqPq+ajSqheGwajSqunGjqu/ryWWVV1ioUliodxQWqhYW6rRoVFv6vv7s+xrxfT1DoY0fFzfeO+/8X6IRb340asqMFnlhb/oH0734+JEKPRWcMtr6Uznt/WnTdVBD4awy+244SOEThTEKrSr5d42W09bonv5vbje72c1upbdly/T1Zcs0f9kybbHpONwQ9Jmn+9dff62Xm18Qjaqu/33126XH1qrKmjXadc0azV2zRn/omlJ74SugLUv0fzfddJP6vqrv65e+rw1L1NNa4fqgvjbBsZEKsxT674nfA7MUuLgf94HH9/R/I7tV7W23R/CIyDjgeGCNBhl/RKQOJhqiBWYJzGmqul5M1MJooC/GDGuIqn6/Wxts2SvwPAToEI1y6rRpDHnmGRp/9RUkJRE95BBmderEdbffzi+l7mkIXIJRzmsDn2GWeb3nuvi+v8mPZwTQnpycKHM+/ZG+/c7GGDH3As5CtT8iNchal83C3z4kLe1Op3nT+VCBtbVbejbMAL6l9P+0Iq9i1gzPw2ZJsVgs1ZSyInhSU1NZvvwvCgocYmMhNhYKCtD4eCQrC+rU4VERripdViSCC4zBeKlNCIV4RIT3MOH2J/s+f/D7olto0nQwiYmxwW1rRLhNhGfFERezfLcTZlwyGdVwibZur+8u7ZX23RZ9t8hRwO3AD8CrqH67o79XRbEeDhaLpTpRwnB5VloaJwEg0h+TDfcjVO/WJ5863B9y3gcSHxtfNG3GpLiT+g5HdYsMupmZ9Aamff75x6FBg/pQWFi4RT0DBgzgjTfezAcyKSo6UeJia2Mi5Vdjoi3XB3VfjxnTT8PYIeyR5S9iErr0UtXGe6J+S/XBqchFInKdiKSWc66hiFy3A3VOAHqXOnYDMFtVW2Mc0G8IjvfBZAlqjfFAeWoH6rFYNuG6qOvyQ1wcN598Mk2nT+fAZ55hXNeu5H/8MX3GjOHns8/m7/feY6Tn0Ti4Z7XrcivQHLgCE4r/DvCL5zFUlSLHYaycflpHGTpkHF98sZrjenXCPJSmY0SXcxBpiO8PJhr9g27dBtC06U9+YdFPvs9VjRo1Kr/RIvth/H9qAC+gOrech0oCRtmPRyR+l/1oFovFsnt5uvSBqVOnEok4+D7ExIAqfiiE5ORArVp8w+bxwiYiEeKAiRhx54FQiGdF+FSVWN/nFt/nSmAZrdsMIzExVlavLJRZH9zkODRyHMaK4KNahOo7GFPmJsD/IbJPhb6FyH8xfXcsMAHVeWX03cnBPoqZQKhMvB08brFYLHuMtDRWACOB/unp9A0OFwBhzDshMmL4nEhuZP9oRCMxJ/Q+3X9u3MuIHIHIJl+a+vWZAQw+7LCjePrpV3GcLV97J0+eDNAD3w8B3+h11/8fxgPo+VJiUS7mnTkFM+G6p1gENAp81SyWcqmQwINxNG9ezrmmwfkKoapzMMZVJemP8Tsh2J9U4viLavgaSBGRbbwRWyzbJxB75g8axPlvvUXNa66h38EHM2/6dFIHDeLWs87ir5kz+cnzuNzzaOa65Lguo4FWmHW4RRhjzT89j2u1+2Gp8uILK5y+vefKfq0nAzdhHkCTgXTgShznQye14SFy9VVdeeGFaaxeVRd4ePnyDD74YBaDBw+mXvLm/ro3LMFk+VoHPIPqFuneSxEPbAg+p+zaX8tisVh2D2r8BD4t/vuEE07wOnY8ZJO4IwJFRTgioErYdTlNhEjJMiIRagLvY3zYro6J4XNgtu+jqviYqOBegEheToZz8w3TpFnTr50+vb8T2Zxyt0SjfgSexbxcnIvI4YEn2lYIcIz5OBBYBYxFdUU5X7e4w8+j8vvtrYSz7Ry3WCyWPc2jGEHjsfR04jFi+EagKSJxADXqJy/dEHZ6RSIg5w3tq5On3KmOMxyRlsWF1K/PqzfddBn9+p3CAw88xXWY0M5ilUYc+ZuuXZ5m1aq13Hvv6Rr1Wqu/lel9XrAPAftW4nfeHr8H+zZ7sA2WakBFBZ5thfDWgi0HWDtBQ1VdCRDsGwTHm2DSVxeTERyzWHYZt93G+9Onc3AkQqPmzXl69mzyBwygfe/ejHrvPZZHInzleVwFNHZdXgE6YF4QFgIP6MWX/OZNfedYbbMfsmxZjONwL+YBcCJmJuB/QLrv87o+OipBrrrybCet+e1y7DGPO9/OfXW//dpExo2bQMbK1SyaOInnB5y69v3ExNcwHg/jUd1QdssBERcj8KwOjliBx2KxVGemARx99DF1p059J1xYKHgexMeDqlmitWEDJCczSITlJW+MRGiIST9+ODA4FKKp7/O2KvGY8XxNERDhN8dhoNSvd6ncf/+v4vsA9cptkeoa4BngF6AncFYS/AxwDiasszVG/e9t+uJvMZE74bILBDYLPCuo5AieQDh7qcQhD2vQabFYqjBpaUQwNgktMQlQigWeELDJzL5+fT7Jzpa78vKAk0/uwdffnK2JiUMQGYhITYDnnhszf9Qjd3HuuRdyxg13MgSzPra7EUzOl3nzcjn//CMReRPHuR8Yp0pcieYUCzwue1bgWRTsrcBj2SblCjwicpiI3CQiNwWHhhT/XWK7ExiFedGtDMoSlmzaL0ulEA6z+pdfGF5QQH3gsnnz+Ouss6BjRzq++CIPFxSwzPOYC1wDLHZdjgE6s3HDp/Tt182f/0t/b/Jbh3ge+zsOnuMwzXHog4n8GQUcDXys67K+9gsjCWRmfuwc2m1J831ajJ3V88hlmS9MKGp15FEMef2Nerpu/WV+1O/le9rF97cpxBYLOqtK/W2xWCzVkQSAGTNm3FtYaPoz18UvjpkJhyE5mUcDP51NRCLsC3wB/MdxeNl1GaXKlRgxI0sEHIelIgwU4UAR3pRIpAZsyo61bZFFNQJMAd4FWoThpSsgYyBG8ZkCdIfMq6EPqu9RMiNL2SQFbVu53bp3DcVL3PuoasiKOxaLpaqTlsaHwOvATeHTz6+PEXighMATMDIc5tucHPLp3PkQlvzZS5s0aQ9cgkg3haMi99/214IXn6HpVbfw5bDLaA3ZnxuBJwsYK7NmLsb4pv0PGAJ8qEr9oPziVOxrgH2C7Ih7giWY92Ar8Fi2ybb+gR4N3BVsClxU4u/i7SaMknrFP2zH6uKlV8F+TXA8A2hW4rqmmDSjFkulEQ6TGw4zJhqlBTBo+XJ+vewy2Hdfcu64g0bZ2TwALPE8vgOOk1GPPuEcdfgY5nz6Db16pwILPI93PI/DPA9xHJY4Dtdi/v0OAcKEYh7T7394yZ81uy+HHnpIjU8/lZkXj8iT5k0/lxHD32fBgt+BczHGzn/6Pvf4Pv8to7m1gn0mJpLOCjwWi6U6k3DAAQcUibjDioqgsBASE3FUwfNAlTUxMWzh+xeJ0AH41nFo5jjEijAEqC1Cngghx+FvEQZCIOxsXoqVAKzHLL/aft9p0lPMwywB6/ow/PEHsAIWHwDv/R+8CNSq4OA/ASgM6o9HpEaFfp2dp9hHcdU2r7JYLJaqxdWAl33t3Zdixrk5wP4lL0hNpQg4JzcXwmF+1voNOrF0WX/t3n0Dxu7g+QdVX7rthotf+nD61KKOd4/m8KtumYvpD2sDrREREXwR7gju6QzMVeUANgs8azFR83vELkRVCzCm//vtifot1YdtDULuwpi7JmAiaQ4P/i65hVR1/8BX55/wDjA4+DwYeLvE8XPF0BXYULyUy2KpbMJhouEwE4GDgGPy8vhi1Cia7rMPeSeeyJzFiwG4R+8YOd1/ddLpFBaukv4n/EhGxqPAoRhx5kvP42TPw3Ec8h2HFxxXuvLwQ0P48suF9OhxoM75vEvHr75OPeissxKolfKwjH36UuegjpOkSaOHmDXrNlQXAtcDv/g+P/g+1/j+pqWKxQJPGMjGCjwWi6UaExMTkzhlyltufj6iCgkJFILx39mwAUQ4ToQogOdRLxrlScfhO9elDpAvQmYQrYMIS0Q4la2FnWISMKH3OVQkikbEQeQITCbQrwUWdgL+Mn3vMEwE0ZEYr56a2yktEcjHCDxQ+X23FXgsFku1Iy2NDGCkX6/h4RuGXd0aWEoZy6RSU1kEXJOXR7vcXMbiuvsyc9atesQRdTDLu2RgNJq88MIzYuTPP5bmXT+y57rvlk4H/sJ4v55SnKhEhImYbFrxwJf62mvtg2qKPWRbsuf4HRvBY9kO5Qo8quqpamGgFtZQ1c+Dv0tuO7xcSkReA74C9hORDBE5H7gPOFZE/gCODf4GM0v2J7AYY3I4Ykfrs1j+KeEwGg4zOxymN9BBlSlz5nBo584c2Lw5b304av5ECgsj9Ol7sn4wqxO1a5+AMa+8C2iIid5f6HkM86+6pjZwhnPdtfs4R/R4TA7qeCnPP/9BtHETr92LL8fo4iWv+B99PMofN362rF69yOl9nOuEnAnMnr0vcDnG4PlBYIXvM9uf9u4grVvXxbxgWIHHYrFUax555NFD0tJaOapQWIjGxxMnArm5IML0xETmex6Hex6vqLJShOGYCJzXHIdYxyFVhJUYk+UOIkwu0zzZkIgReDYC2xZkRGphJqCOwoTJZwtkvg1+pinjdOAbNmfdugiRbQ3Ci+vODv6u7GVaqYCPifa0WCyW6sQoKchfunHEjX28WrWXYSIlm5Vx3VPA9NwcHRoZ/cSzeF4SH8zsr+nLnwZWnQhtOxUW8vugvncBP/vNWryUuaJgESaD838x2RKbAogwFzgYWMxppz+sI0c2Vdd1MMtq96QPTyPgIBFREYmKyON7sC2WKkqF1hCqaqGIxIvIhSLysohMF5FWACJyioi0rmiFqjpIVRupaoyqNlXV51V1naoeraqtg31WcK2q6sWq2lJV26kJjbZY9hjhMD+Fw5yDUe8f27iRY0+9o/0ZnTsUFdx40Ac36h23LyYvLx+zfPEWzIvHZMzswTN6+x3p/kuvDNXOnecDSbJgQUPnwgtGNti3xXP9+vbJJS9vLj0OP55zzv3O37BxsP/Ci9kaCu3nHHfMKY4rUx2HQzChmSOB5vTtd61m/NXdX515h//Qwy2wAo/FYqmmdOvW7aULLhjWpaAAolFITo4qGHPlggI0MZEfgAXAp6qcrIqrynLHYbXjMEiEeEzmlabbEXY2GdSvpkHkD1oVsS2BR+QAYLg2a5amcXFfYoT7BsCUURC5z7RJgPO1UeME/4knp2rr1h5wJiK9gro2oYpo48Yp2rNnvGauPVhr1ChOv1uZpAKZun1vIIvFYqlSpKURif94+l1+7bq110yY3i443LH0dampaOLj999AQb6/4fD+A/2RI88lFFpF48bT9ZZbus2DD98Fai5d3DXluINfJlq0hri4dzPX6DpgPKYfPw+RHog4ImQAPQiHP+CWW1vy7bwrtF695UAzRGJ32w8QEIg57UsccoGLrchjKY1UJAhHRBoDH2Feav/EmMYerKrfi8hzgK+qF1ZqSy2WKkhyMrV7Rmc+/rV76PF5klRzdl63eYf4Xz/sRfUT4BTgVFSPQMQhO3sjaISU2vX4du6PbrcuE4E3UP1TRB4ELlbVBH/U6INo2eoeDj/8UOLjo3L0UQfJF1+cgFmO9QnwOaq+7yNy5eW36kGdL2TQmfEsXPiec2C7pcB9mMg7i8ViqRaEQqHHP/ro44sPOugwfF8oKIhSt24IMGKP4+CL4KjyjSp/Aye7LrkiJGIiG6PAiSJ8uL26RHCbk95rH5be+QXdW3bi+xVfhw5broVF/wc0B9KA5hQVtWD16i7ExTanVkoSsbFxvPTiB8THR+h5dAZ16yZMnz797P322y9z3xYt8olGU4mNNV46BQVPyosvZBKNdqZNG4dDD91AYmIDjBdbUwIzaQCOOPx++eyzz1B9b+vW7hpE5G0gTVU7VFYdFovFUmmI7Lfy7bmTI+0PatWo14HzYn//ZTqqd5e6pj1wQvi6ka1zr7x1sGStfaTBwCMymfbuCFq0aPrVV1890v2w7ldfBpeOhhpFXQ5rkv3GrHOJi81FnO71G8gazBLcAzBLwaagGtYmTetw880/MHx4c3JyvqFVy49kzZpxqC7evT+BRDGiTmk8VQ3tzrZYqjYVFXhew/iQ9MWYO0WAzoHAcxZwm6pawyfLvxORIeupHds54desJXmNLgEmofpUcK6Odug4RAcPOUoHnNqMRqntEMdh48b1oC9Qs9YrMTHOEFUdjomo84CnFa7VlJQB9OjRXaZN+wiYARwHtKPEQweRi4Az9KST+pOV1VrmzDkeeBpV67NgsViqDSNGjPAee+xJJyWTH94AACAASURBVC8PIhFISVEkSJ3l++D7TA2FuEuVexyH40RAlSUiNMQYYPYR4Yfyyl+1isSbb+aUX37hrIUL6R4Ok5RQw9c+vTRv6GAv1Of4UBxOqaBmVWP+UzaR3NxcDYfDcao+ruuSnJwcqVGjhiulInbwfZ/wxjCOu5Tk5D+ADO6//1hyc35n5J0PUa9uJ8nK2oDqyzv9A26DYHb34uBP84yxWbQsFkt1QqRlZP8OI1a++91FCe9OWlz/sjN/QHVIcM4FegGHYN5T31zz098v+TVr96535H/vcVs0f52PP74f6P/ggw9www03EK/qDYXpj/Q6cUX48Qmnx02bfGnyVcNeC2rrgHnnLcL4wi4GZuujo5ZzySVKXOwf4vtzUZ25e38CKfelXVXLfVhZ/n1UVODJAoar6qRg4FLEZoHnSOBdVU2q3KZaLFUUkRHAOlQnITIT+ATVe4KZhH6YLHTTgTbaqtXB+r87k/XUgfviuj2B0NKlS5ky5U0mT36TuXPnFpf6hMKlGLPmY4B1mFSRjYMyizBeD/0xD7VjMetyLwQmovrbbvr2FovF8o9QpXlOTk66SCKhkBAKFYs7SmGhx/r1oW8aNeJJ4HERklXJBMYBl2Gybl6HiYhpDbTARMg08H1q//gjtV5/nbjXX0fS0yEuDvr2hdNPh379ICHBNIDCQp+YmCwcZwM5YSVrfTyu41Gnbi6RwroSCiWRmBiP42wh3kQiEVatWkV6ejoZGRmEQqEfBnbo8A6TJrbgt9/yCYXeYu7cefLbbydjsoJ+hxHs3wU+DZ4VpwENUN3lYfalxJ2SPGFFHovFUm0QSQOGrn3g+a/q3vh/HcWLHoMZD8cCp2H6168wfjpHew0bHxndv3123McznkQ1HBsb+8SoUaNGDB8+gldffZXzzhtKJBLhPzB+QWLSt5Kb0xAzgfoeqmsRqYfxckvF+KtdBcxG9T5EBgM1UH169/4ENoLHUjEqKvDkAqeo6gdlCDwnAC+raq1tl2Kx7KWIXAv8huo0RN7CKP1fAgcCyzEPm74Yz4bZwBeoqudR5/zzh2YOGHCqc8wxxxIbG0vXrgczb948KNlZi7TAPGTiMC8FfwEDMT4QLYE6qPZDJAHzojMD1a9307e3WCyWncbzSBLhK8/TAxxHNgXNFAfORCIQE0OeiFnSpEq+CC5mUF8mixbBxInopEmwaBESHw/9+rFhwAAy+vZlWXIyuazNrClr1rSidescotGmxMXVwy01bvb9CNnZYdav30hy8i80aLAAyAAyBg48dXKPHoe7p5wygKVLl3LEET02fSVVDSGShFmmuy/wI0bUOSzY1mLS8E5C9TFEjgW6AnexE8krtoV9IbBYLHsFIk0w2QpfwWSRuhZ4JPgci4m0SceMj9MwosxMAt+x4r7w+uuv56qrrqZLl0NYtmwZgKfm/oOAo4EYzBh+DmaC9hhM/zwAM76+FpEewbUPoZqzG749wXewgr2lQlRU4PkG+E5VR5Qh8DwO/FdVj6rktlosVQ8zzXwrxhfnI0TewKj9HwKfAisw4owAb5Zer1scblmrVi169erN669P2nRui3BLkeSgnDRgHjAL83C5BfNgOg6TbvdG4HtUZ1TG17VYLJZdhecxF+hMcU+6g7djxJaVQNaSJRTOmUOjVatomZRE/aZNoU0bwi1a4CUmUlOkVFIJzytg3bpcatf+mZUr83j77Q7k5f5Jdvaf1K//PrM/WscHMw4V31+PEWLW+D61MNmyhgJdo9Eo06e/z4QJ45k6deqmojf13SIOJtXu4ZjsVa9jvNTOxmTkegm4A/NicTzwCKobd/iX2AY2pN9isewViDQEhgOTMOnKp7N5EnUSJqX5wGD/Dqo/b3n75r6wdu3arF+/ftO5En12EiYi/kBMhsPpqC7CJBOaDGwArsA8dy4EJpeup7IJ3rsvwgj3PvCUFXcspano7M0jwKsi4gGvBsdaiUgvjJp6amU0zmKpBtTAeOfkIdIdEyIawrjxN8UM5DMxy6ayyrjfA9wNGzZsIe4Exzdj/HZeAHpiZoAbA29gZivaYDr7d7Gp0i0WSzVBhGVAx6IiHBGc0KYRiQImmkeVCOCK8KEIzYD9gQwR1ngezV2XrgCtWpkNoLCQQhHSY2NZRhBxs9UWH9dePO8o4D5gCCZF7i/AbUB3TD/7u3Y66C39dl53fIZiInLigQXXXnuN/8orLzurV68u/bU2992qPvAxIssxs78XAtMwLwpnAP8Jjv8a3FEbk7J9V+JRTgTPLq7HYrFYKpNosI8HemDG3zHAsxhBphdmDPwyqlt1zJToC0uKO2zZZ+cAbyHyPWb51yBEFmHEpF+BusAJwEJMsMO+wG4VeFT1EhG5BjOpO1ZVr9id9VuqBxUSeALvnUbAXcCI4PBEIB+4RlWnVVL7LJaqTgImgqZnsF+JeeAcjDFEXghMRbWwnPufpuxwy63X9ZqXhQ8RWQGcDPwf5gH3A7AK8/KRjIkWslgsliqLKokipHgeeB6O46CgYrov04UFnsfFS7F6Afg+hevWIb//Ttqvv1InIwOys1kRCjGrbVsmDhvGN/HxFRBJPC8B01cPw/iXZQOLMH1rYx069A999vm2iPyGyayVjRHuxwPzHnnk4TFUvO9egsjTmMmwAZjZ5zWYJQT7Y7yDkjHifPp2275jVPwZY7FYLFWXKGbMOxAoBH4CkjCCSzvgd4w3ZWGpFOYCkAjPRE0E0BYn4uBZRGqw5dh5LSbC8hBMBGZbTPTlSuBboBsmoj4WkXd29dLa7aGqBSLyOSaS32LZigot0dp0sUgtjGraAGP6OkdV12/7LotlL0akG/A8Jkw0G2PweQDmRSGMeUgIJsqneImAW+KYzIf910BTAXFAG8Lf+8OS4Nri+6TkPZgXk1iMDw+YZVtgBKdE4DhU11XKd7ZYLJadRJXmmIH5VpGGZjiiQeSOoEqh4/BAXh4nf/QRB4wcyW/ff08rzOTUH8BrwCTVTREwFUfkZkyE5c8YgbyfJiXV5PwLsvS881I4oF0DfB/mz18hE1/7jaeeWi45YSjRn38CXf6C/YJOWZvDkkON307JPr9kv+0CdTAvCk0xHg8bMS8tdYLvdO2u7rttFi2LxVLtEUnERKqnYuwP6mGEl78wgk8um0WakuPmTdsKaJINdYsPpEBWE1jN5vH5VveU2JIxXpg/Y7JJh4I29EO1eMy+2xCRG4B7gUZqM+daSrFDBnuqugHzP5fFYjF0xczursW8JDTBCCzNMTO09TFrZLXU5gf3++1h1UooSod9D4Tva0AB5mHjYwbj0RJllNz7mBeFRpiXpQ+BjkB7zAyHnaG1WCxVjUzMEqUzfZ94x0GiUWOq7DhKXp4QGwu5uejw4dy3cSNXfPwxtQoKANO3PoqJIP5BlX8ya7ov0EJFCjnxxCZ68inNOPmUGJKS6rF0aRF337VWxj2/UZYti2JmatNK3a9HAksgEgsFzcxLhmJeOGDLvr7051oYMb4FxsxzI6YP7w/MZRf33UFI/zDgEVW9cVeWbbFYLLsF1VxEFmM8y/4IjsZjRJd0yh4jb/G5GfyxCvb/E9oOhInO5vNeqWtL3u8F25GYCdwNGD+1wzERmMeyeVJ2dzI72Pdks32KxQJU3GT5kG2c9jH/2JeoWUJisfx7EKmLEVPeQHUdIk2Bq4ExmBmG6PZCN4PZ1eEYUWfHZldNfZcDo1HN2Ko9FovFUsVQ5SXfZ5AqbiDckJgIGzZ4uZ9+6iS+8QZMnizRggJC9euj9erx9sKFPAR8pcouGWf4L73cnlq17qJP33a4bgui0TxmzcxgwYLRcustMyUSiWIG91E2i+ylP/su/OjDQlWtuBdh6X7bHKvUvltEcjB+DVfv6rItFotlt1CynzSRj1v2oxUqQuZgVqPAjoy5q9h4O0h6tBaYoqrn7+76LVWbigo8xSrmttgAPKqqd+6Khlks/wZsykOLxfJvQpV+wLvZ2WSHQmaZVlISTJ6MXnihyvr1QkqKcuKJEjnjDHI7d+a4+vU3LUH9R/g+CRiPnaGYWU8BPsL46rzlOOTuSHnVaemTiKwHXlLVy/Z0WywWi2VPsLeNuUVkCtAJ2Ed3sw+QpWpTUYFnAPAwxlfkTcx6xYbAaZgMPndiDKcGA1er6ujKarDFsjchIlHKyXCiqju0hNJisViqMqrUAhYUFOAXFdEsGjXiTkwMjBv3Y3TmzA6hs8+Gnj09Vq5c5rVs2bKNCH/+kzp9H8EspR2KSXFeE1gGTABecByW7Uy51e1FQUTWAJNVdfh2L7ZYLJa9kL1tzC0iYYzRdDFrVbX+nmqPpepQUYHnaSCmrBAwERmH+R9jmIg8ARypqv/d9U21WPY+RKTc/wFV1WbDslgsew2qjPV9LtiwAc91iXFdSEiAvLw8Xbx4pey3X3Pi4mJYsGABRx99FJmZmTs9WPV9GgPnYFKgtwXyMBNU44E5jvPPlnpVtxcFEckAPrCh/BaL5d/K3jTmFpFMjMlzaazIY9nkGr49BgKTyjk3EZOeGeB9jHGhxWKpGN4OHrdYLJZqhyo9gQs3bOCPmBhiRIzvjgi88MKL0rZtS+LjY8jJyaVbty5kZmZC2YPXcvF94nyfgb7P+xgPtPswHgXnA6mOw2DH4ZN/Ku4ElCXubOv4nqYIk33RYrFY/q3sTWPu8p6PO/TctOydVFTgiWXrDBLFtGDzoKEAkzrOYrFUjPKypdgMWBaLZa9AlUTguUiEZY7Dfr4P8fHg+6DKitTUFoRCPqpw/vkXkZu72QpHRHwRURGJBsuitsD3Ed/nIN/ncWAlJrtJO0z62NaOQw/HYZzjEN7FX6vavCgEM70tgHOC3zJzDzfJYrFY9gTVeswtIo8Hz0Lrt2PZJhUVeKYD94pIv5IHReR44O7gPJgw6KW7rnkWy95N4NXwBJvTpntUUQ8Hi8Vi2UnuUmWfjRup6boQCpnNccD3eeSoo47D95W1azfw5psvl763OGzeBS4WkZ9EJNqgQQO96qqrvYyMjLXAPEyUzgzgOKCF43CL47C4Er9TtXhRKCeMv54VeSwWy7+NEmPuYoGk2oy5S/i+VdUoUUsVoqICz6XAn8A0EckTkXQRyQPeDo5fGlxXANy/65tpsey9BA+Ws4I/21WHB43FYrFUBFUOBS7fsIEv4+KoI2J8d3wjac/PzaWp4ygxMS7PP//8NssKhUL079+//VtvTXVXrPiLhx562MnIyKjz0EMPfgI0chzOdBxmOU7lR9FU1ReFkjO8gU+QDeO3WCyWgKCPngN8qqqhPd1n7wAXVfRCEfmpMhtiqfpUyGR508UiJwJdgEaYUOivVXVaJbXNYvnXICKDgFeBtqq6aE+3x2KxWP4pqsQDP0SjJG3cSJOYGKRGDSPuxMaC73PC339vnFqzZpwbHx8iJSWJgoKCrcpp164dQ4YM5cwzz6JBgwasXLmSl19+iRdemMDChQthDxobi8gnAKp65J6ovyTbyOxVJtXNVNRisVh2BVWp394WQZ9+ETsXtTNfVQ/cxU2yVBO2OyASkVhMetHPVPUd4J1Kb5XF8u+jOJrOrqu1WCx7C7cBbbOy+DMhASleluWY3u6TnBxSk5JqusnJMGPG7C3EnTp16nDGGYMYMmQoBx10EJFIhGnT3mHChPF88MEHeN4WQTr/ypD1UoN/j4pHZVssFoulCrOjgn0ZtN9VbbFUPyqaJj0f6K2qn1Z+kyyWfxciUogxMi8moqpxe6o9FovF8k9RpRMwNxzmM9/nyJiY4pToZq/KQeEw4yKR/APr1atBhw4dWLDgF4477jiGDBnKCSecSFxcHN9//z0TJozntddeJSsrq7zqfFXd7SLPnuy7d8Hg36bStVgs/zqqy5g7WGL7j55rNkrz30tFQ5oXAc0rsyEWy7+RMh40ALEiUlgVHzgWi8WyPVSJAcYBmaEQbXwf4uIgNxc/IQEHeDMcpobvc2BKSjwrVvzFoEGDOPvsc2jcuDGZmZk89dSTvPDCBObPn1+RKnO3f8mupQr03RX2YyiHv3dJKywWi6WaUAX67R3hXxmZatk1VDSC52TgAaCfqv5e6a2yWKo4ZYTGP70tozYRiQcaAqnB1ijY376Nam4GVgXbymCfqarRXdk2i8Vi2ZWociQwC3g4GuV6ERDBj0ZxYmPxgVYbN3KP5zEgJYUYgGg0yvvvv8eECeN5//33KSoq2rEqVSu0PGln+scS/Xdxv50KPLWNW/qzud9eraqRXd2uXZEm187uWiyWqk5F+0YRiQEasOUYu/TWfRtVPc3mMXfJbbWqbm0OtwNt2xm2EcHjq6orIsuAtG0UYT14/sVUVOCZBRyAybqwCDNoKXmjqmqvSmmhxVLF2EZo/CzgQ8p+uKSUcb2yOQVwRVEgk60fQMUC0GnAyWXct8ezu1gsln8PquyD6a8WYwapz2L6pic2bmSsKstjYnDj4ym65ZabZNy452PWrFmzs9Wlq2qL7V20jb77HWAy5b8UlNV/7whZlP3iUNxvnwcMKuO+cvtt+f/27j1qkrq+8/j7y21gZpSbokSFAaNJ1ChujPeogXhjXS8n3jGiyZpw8ZhsPBpFY4zuomsSs0YIRKObZI2XuIr3C2pcjWsSDZ4gKBqVHRBBLsMAMgMD88x3/6jqTE/zdD/d/fQ8Vb+q9+uc59TT1dXd354zz7erPv2rX0WMm3MngV1M8e2vAY+kNpvQs78BfJs9+/S4KwNuZXevPX7Cy10LjDttdSt37N8PAx65zLYL2d+e8N53An8PPJ7qGGLcsYQBT49NG/D8EytM/pqZj1hUUVKbTXFe7M2M35Ef/rkWmPTN7nr2HPUz/DN6IDI65HRUY1eZkdRPmQRV6H0Q8GggIli68UYencn77nxnjvzSl778g+OPf+x9V/Ey24GXZOZ7V9pwyjkNhvv3cn178POjCc/xi0zu20dS/ZusZGzfjoibgDut8PjboRohtRwDHklttkLP3szKvfrqzNwx9Hxjj2UzM0ZGAU36ORLYMOapFra/PWWfn8SQp6dmuky6pBWHxt8pM2+e4bmWOx8YZpj0LSKC6hvmu1N9o7Esd+YlrbU65NkQwR59cdcuXhbB2x784OOWLrzwwnnmGkjgcuCMacIdWLF3/zTVwcBU/Xs1vbvu2RvZfbDw5XHbjuvbEbGL2UeADnPHX1KrrRTIzPF8q97n3lu1jXmN1fZ59/17qhUBT0T8DPCBoVXHUl1e9RDgJVQjHaDakfvUGpcn7WHCNwpzpfaLnNF/0bVJ0t6QySbgKfvsE2+f8ylm7mlt7d3z1DXF/AuTeAUtSa23N/Zpm+zbc7zGZubv84ABT19NNSnhQERsiIgHRsRDR39WU0Rmfjczj8vM44BfoBpyfV59958O7jPcUUucO+P6iTJzXWbG0M9qZvJfaG2StDdEsDmCs1bxFPOM+mlr756nrjOo9pXmcZd6fgdJarOF79M23LdntZo+D/z7XD7qmWnn4DmA6j/sCxizU5WZC7mcW0Q8AfiDzHxURLweuDkz/3gRzy0tysjkZ626UlVEnA2cVt9sVW2SNGw1V4Oac4j++VSTU0KL+mP9mXIq1Rdv017d6/nAmcBRzD6M31Gdklqv7o2nUfW41vRsWJtjgZE+fzmz93t7fQ9NG/C8nmrH4wyqK2H8LrADOBk4DHhFZn50IQVFvBv4RmaeVb/ui4CbgH8BXp6ZWxfxOtJqRMR6YBvVaYNvarqeUfUQ1D/NzFc1XYskjTPlxMfLmjPgeTXVzvKGzFzVN6OLFhEvA94G3CUzt8zwuLn+DR26L6kEEXEx8L3MXO4qsY2KiK9RnfZ64hq93sxfitjr+2faU7SeA7wB+Kv69pcz85zMfDjVpK6PWUQx9UihpwIfrFedA9wbOI5qhvQ/WcTrSAtwZL28qtEqxtvG+Bn+Jakt5h3Oftmcj7sHcEPbwp3aLfVy/YyPmycgW5rjMZLUhLsBVzddxBjbmb1nr8auNXwtFWragOdo4KLMXKK67Obwf+R3AM9fUD1Pphq9czVAZl6dmUuZuYtq5NCq5vqRFsiAR5JWqR7Ofv6MD9tONaJ4Hj/F5EucN2kQOk1zCXXg34fvz8N52SS1XkTsBxxOuwOetdzf3raGr6VCTRvwbKG6pCfAFcADh+47hMX9x34e8L7BjYg4cui+ZwAXL+h1pLnV59x+qb75ybZNYFbXc0/gxRGxs231SdKwzHwicN2Um18GvGTaS6MPq3vhM4D7t7Q3nlQvvztDfWfO80JtmcNCksape+CtVHPOvLZtPbuu50nAQ9bwM2XjypvsYd7RrirYtJMufZ0q1PkU8BHgDRGxDtgJvAr46moLqec0eTzwW0Or3xIRxwEJbB65T1pzIxOqQTU0/vSIaMUOc9vrk6QxfptqpO64oe7bmTPYgfb3xrq+Jw+tmra+o+Z4OU/PktRqy/TsfWhfz27iM+VyZrt0+ryjXVWwaSdZfjiwKTPfHxGHAH9LlVgG8K/AMzPz0r1aqdQCEyazbMUs9W2vT5LGGblayGCS4cOpdmjPmDfcqZ+71b1x3voiYjOz7ewDnN2GAyRJGqerPXsBr/t8Jn8ZMuy6zLzr3qpF7TVVwLPsAyM2Ausz85rFliS116TZ69swS33b65OkJrS9N85b34w7+wDn16fESVJrdbVnL+i1B1+GTAr3VzXqVWUbOwdPRFwaEQ8ad39m3my4ox4aN7S9LUPe216fJDWh7b1xrvrqnfeXrLRdff9JhjuSCtHJnr0ImfnezNxENW/bcleEvA7DnV6bNMnyJmDdGtUhlWLclUfackWSttcnSU1oe2+cu756J/6FLL+jT73+he7sSypIZ3v2ogwF/JdRzVd7GVWQf1f7fb+NPUUrInYBD8/Mr61tSVK7RcQ5wCn1zSXg3DbNZ1BP/HYqVYDbuvokqQkR8c/AQ+ubreuNEXE2cFp9c+b6RuYw2kX1GbDq+YskqQn1/uxpVHO+trFnu7+tVlop4HlYZn59bUuS2i0ifha4BPi1zHxP0/UsJyJOBf4c+KnMvKrpeiSpaRHxN8DjMnOeK0+tiYi4DvhAZp6+4saS1HER8T3gG5n5nKZrWU5EPAn4NPCozFz1VaWlRVhplu8/rHc2VpKZefIiCpIKcEy9/H+NVjHZ8BVoDHgkCY4F2n7Fz+uBw5ouQpKaFhH7UI1IPK/pWibYWi8PbbQKachKAc9xwI4pnme+S3FJZSot4JEkVQHPZ5ouYgUGPJJUOQI4gOpU07a6oV4a8Kg1Vgp4nu4cPNIdHEMVfP646UImMOCRpFpErAeOpIwRPHdtughJaoHB6bRtDngcwaPWmXQVLUnLOxbYnJm7mi5kAgMeSdptU71se8CzBfu2JMHugOeyRquYbBDwHNJoFdIQAx5pdsdQxkECeKAgSVAF89D+3u0pWpJUObpetnYET2beDmzDETxqEQMeaXbH0O75d8jM7cCtGPBIEpQV8BwcESudQi9JXXcUcDO757lpq60Y8KhFxu5AZKbhjzQiIg6hGobZ6oCn5lB/SaocS/Ut67VNF7KC6+vlIcA0VzGVpK46CrgsM9t+MR8DHrWKIY40mxKuoDVgwCNJlWOBSws4UBgEPJ6mJanvjqbFp2cNuQHn4FGLGPBIszHgkaTyHEv7T88CAx5JGjiKMgIeR/CoVQx4pNkM5nEw4JGkAkREUMbk+GDAI0lExAaqfVgDHmlGBjzSbI4BbsjMrStu2TwDHkmCI4D1lBHweAVESSrjEukDBjxqFQMeaTatv4LWkC3A4RHh37mkPivlClrgCB5Jgt0BTykjeDZGxP5NFyKBAY80q9ICnn2Ag5suRJIaVFLAcyOQGPBI6reSAp7BZdzd31YrGPBIU6rncdhEWQEPONRfUr8NAp7NTRYxjcxcojpYMOCR1GdHAbuAHzVdyBQG0zZ4mpZawYBHmt7dgQMx4JGkkhwL/Cgzb226kCldjwGPpH47mqpv72y6kCkY8KhVDHik6ZV0iXSA6+qlAY+kPivlEukDBjyS+q6US6SDAY9axoBHml5Jl0gHR/BIEhjwSFJpjqKMK2iBAY9axoBHmt5gBM/mJouYgQGPpF6LiAOBe1BWwLMF+7aknoqIfYF7Uc4InsEky4c0WoVUM+CRpncMcFVm3tJ0IVO6gWqCOg8UJPXV0UBQVsDjCB5JfXZ3YD/KCXgcwaNWMeCRplfSJdLJzF1UHzoGPJL6qqRLpA9cDxxSf4stSX1T0iXSqb/43YEBj1rCgEeaXlEBT82h/pL6rNSAJ4CDmy5EkhpwdL0sZQ4eqL5QNeBRK+zXdAHDImIz8BNgCdiZmQ+JiMOADwCbqOY+eXZmbh33HNLeEBH7U50PbMAjSeU4FrgFuLrpQmZwfb08bOh3SeqLokbw1Ax41BptHMHzy5l5XGY+pL79KuALmXkf4Av1bWmtHUX192LAI0nlOBa4NDOz6UJmMBzwSFLfHAXcmJk3NV3IDLbiJMtqiTYGPKOeBvx1/ftfA09vsBb11+AKWiUN8wcDHkn9Vtol0sGAR1K/lXSJ9IEbcASPWqJtAU8C50fEBRHxm/W6u2XmVQD18ojGqlOfDQIeR/BIUgEiIigz4NlSL+3dkvroaMo6PQs8RUst0qo5eIBHZeaVEXEE8LmI+E7TBUm1Y4CdwBVNFzKjLcD6iDgwM29tuhhJWkN3ATZSXsDjCB5JfXYU8JWmi5iRAY9ao1UjeDLzynp5DXAe8FDg6og4EqBeXtNcheqxY4DLM3Op6UJm5DfBkvqqxCtoQTXUHwx4JPVMRNyZai6b0k7R2gocHBGtOrZWP7XmP2FEbIiIOw1+B54AXAx8DDi53uxk4KPNVKieK/ES6WDAI6m/igx4MnMncCMGPJL6p8QraEEV8ARw56YLkdp0itbdgPOqU+bZD3hvZn4mIr4O/F1E/AbVH/uz9+TiCAAAFeBJREFUGqxR/XUMVdhYGgMeSX01CHg2N1nEnK7HgEdS/5Qa8AxGXh469LvUiNYEPJl5KfCgZdZvAU5Y+4qkSkRspJrc2xE8klSOY4GrMnN704XMwYBHUh+VGvBsrZeHUubxgjqkNadoSS22qV4WNcy/ZsAjqa9KvILWwPXYtyX1z9FUFzW5qulCZjQc8EiNMuCRJoiIs4AL65vvqW+X5DX18tyI2Flg/ZI0s7rXPQ54VGm9r671V4CHlVa7JM2r7nW/R3WGyY7Cet8p9fLz9m01zYBHGqNuzqez++9kX+D0Upp2XeepQ6uKql+S5jHUuweK6X1DtUe9qpjaJWleJfe+usbnDq0qpnZ1U2Rm0zVIrRQRO6ma9KilzGzN/FXjlF6/JM2j5N5Xcu2SNK+Se1/JtaubHMEjjbdcs560vm1Kr1+S5lFy7yu5dkmaV8m9r+Ta1UEGPNJ4SzOub5vS65ekeZTc+0quXZLmVXLvK7l2dZABjzTeuTOub5vS65ekeZTc+0quXZLmVXLvK7l2dZBz8EgTjEzWuQScm5kvbbCkmdT1n0Y1aV1x9UvSPCLi88AJ9c2iet/QBPn7UFjtkjSviHgH8JL6ZlG9r/TjBXWLAY+0goi4BLgoM5/ddC3ziIjzgY2Z+cima5GktRARLwXeDhyRmdc2Xc+sIuJ5wHuBn8vM7zRdjyTtbRFxJHAlcFpmntN0PbOKiAuBSzPzGU3Xon7zFC1pZRuAm5suYhVuBw5oughJWkMb6uW2RquY3456ae+W1BcH1stbGq1iftvY/dkjNcaAR1rZRsoOeG7DgwRJ/bK+XpZ6oHBbvbR3S+qLg+plqX3bgEetYMAjrawLAc/+TRchSWtoA7A9yz0PfRDwrGu0CklaO10IeDY2XYRkwCNNEBEHUIUjpQ7zB0/RktQ/Gyi7bzuCR1LfdCHgcQSPGmfAI002SOIdwSNJ5Sg94HEOHkl9Y8AjLYABjzTZoFGXHPA4gkdS36wHtjddxCo4gkdS35Qe8NyMAY9awIBHmqwrI3g8SJDUJ6WP4HEOHkl9U3rAsw3YEBHRdCHqNwMeabJBwFP6gYKnaEnqk64EPIbzkvpiEPDc2mgV89tGdWx94EobSnuTAY80WRdG8HiKlqS+Kf0ULefgkdQ3XRjBA56mpYYZ8EiTdSHguQ3Y3yGjknrEETySVBYDHmkBDHikyboyyXIA+zZdiCStka4EPM7BI6kvBqc2lRrwDI4VDHjUKAMeabKujOABvwmW1B9dCXjs25L64iAg2d3/SuMIHrWCAY80WVcmWQYnWpbUH87BI0llOQi4JTOz6ULmZMCjVjDgkSbrQsBze730QEFS50XEvlRD/e3bklSOgyj39CzY/ZmzceJW0l5mwCNNthG4LTNLHS4KjuCR1C/r62WxAU9m7gJ24hw8kvqjKwGPI3jUKAMeabINlD3/DjiXg6R+GQQ8JZ+iBVXvtm9L6gsDHmkBDHikyTZS8LfANYf6S+qTwc516b17B/ZtSf1ResDjVbTUCq0IeCLiXhHxxYi4JCK+FRG/Xa9/fUT8KCL+tf45sela1R8RcRZwMnCviNhZ3y6Rp2hJ6oW6T/9bffPdBfdtcASPpJ6oe/VTgQcWvM/9xnr5ZwW/B3VAtGGi8og4EjgyM78REXcCLgCeDjwbuDkz/7jRAtU7dVM+fZm7zs7Ml651PfOq38epVGHuEnBuSfVL0rS60rfhDu/F3i2ps7rQu7vwHtQdrQh4RkXER4GzgEdhwKMGRMROYN9l7lrKzP3Wup55+GEjqU+60LfB3i2pX7rQu7vwHtQdrQt4ImIT8GXgAcDvAi8CbgL+BXh5Zm5tqjb1R0SM/cPIzFjLWublh42kPulC3wZ7t6R+6ULv7sJ7UHe0Yg6egYjYCHwI+J3MvAk4B7g3cBxwFfAnDZanflmacX0bLXeAMGm9JJWsC30b7N2S+qULvbsL70Ed0ZqAJyL2pwp3/jYzPwyQmVdn5lJm7gLeCTy0yRrVK+fOuL6N/LCR1Cdd6Ntg75bUL13o3V14D+qIVgQ8ERHAu4BLMvOtQ+uPHNrsGcDFa12b+qme5+DsoVVLlDf/gR82knpjqG/vqleV2LfB3i2pR7qwzz30HganahX3HtQdrZiDJyIeDfwDcBG7d8zOAJ5HdXpWApuB38rMq5qoUf1TB487gTMz8/ebrmce9WSdp1AN7d8FnOOHjaQui4hXAW8CNmTm9qbrmUfdu08DAq+iJakHImI7cFZmvrLpWuYVEecDGzPzkU3Xov5qxWR9mfkVqp2YUZ9a61qkIQdSjXK7uelC5pWZL42Is4FvAydl5vubrkmS9rL1VF8M3dJ0IfOqe/e9gcMz09PTJXVa/aXqQRTct2vbgLs1XYT6rRWnaEkttbFeFhvw1G6rl/s3WoUkrY0NwPZswxDl1bkNOKDpIiRpDayrl10IeDauuJW0FxnwSOMNGvS2RqtYvdvrpQcKkvpgA1DkqVkjdmDfltQPB9XLWxutYvW2UX0GSY0x4JHGGzRoR/BIUjnWU34wD47gkdQfg4CnCyN4DHjUKAMeabyunKLlCB5JfbKB7gQ861bcSpLK15WA52ZgQz2nkNQIAx5pvK4EPIMRPAY8kvqgK6doOYJHUl90JeDZRnXhoAObLkT9ZcAjjdeVOXg8RUtSn3TlFC3n4JHUF10KeMCJltUgAx5pvK6M4PEULUl90qVTtOzbkvqgawGP8/CoMQY80nidCHgycxewhCN4JPVDl07Rcg4eSX1gwCMtiAGPNF5XrqIF1SgevwmW1AddOUXrNmDfiNi36UIkaS8bzFlTesAzOGYw4FFjDHik8QYjeLryTbABj6Q+6MopWjvqpaMvJXXdYATPrY1WsXqO4FHjDHik8TYCt2TmUtOFLMBteJAgqR+6dIoWGM5L6j5P0ZIWxIBHGm8j3Tg9CzxFS1IP1KczraMbI3gGAY/z8Ejquq4FPF5FS40x4JHG61LA4wgeSX2wvl52KeAxnJfUdV0LeBzBo8YY8EjjbaA7AY8jeCT1wWCnugsBz2AOHnu3pK4z4JEWxIBHGm8j3ThIACdZltQPg51q5+CRpHIcBCxl5u1NF7JKXkVLjTPgkcbzFC1JKksXT9FyDh5JXXcQ5Y/egapvL2HAowbt13QBUhtFxLXAXerfE7guM+/abFWr4ilakjptuG8DH4yI0vu2I3gkdV6X9rkzMyNiG06yrAZFZjZdg9QqIwcJw4r8wFnm/RT5PiRpnK71bYCIuAE4eGhVse9FkpbTtd7tPrfawIBHGlF/e7CszIy1rGW1uvbBKUnL6VLfBnu3pH7oUu+2b6stDHikER37sOnMe5GkcbrW67r2fiRpOV3qdV16LyqbkyxLkiRJkiQVzoBHGhIRT51w93VrVogkaSoRcSDVRPLLsW9LUgtFxEOAcaNe7N3SnAx4pFpEnAj8b2And/zA2V7o+bO3jll/e31QJEnFioh1wIeA/Ze5O4FHrm1FqxcRmxh/0HPj2lUiSXtHRBwHnE8Vzo/2ux2F7nPvGLP+tvqzSloTBjwSEBGPBz4M3ED1d7EEXAxcDvwVsH9E/GxjBc4hIp4AHAjcsszd+wMfMuSRVKqI2B/4AHAiVZ/73tDdfwjcDLy1gdLmFhEBvAPYxh0PFhI4ICKOX/PCJGlBIuIBwOeAAA6g2vf+NtW+95nAuoj4D81VOLuIeDKwjuX3uQ8APuI+t9aKAY96KSLOioidEZERsRP4NFWYcxfg48B+wHeBuwK/B2wH3l7vfLdeRNwJeCfwHeCEevUnqd7Hj6ne64lUIY/fKkhqvWX69iXA04ALqPZnrgG+Beyi6uFvBJ4SEU9qquY5vBh4PPBKqp79Xapg53yqg6FrgE9GxAljn0GSWqr+svQLVH16HfAl4FCqfr4v8KfAFuDNTdU4q4jYCJxL9R4eU6/+BNUo+iuBK4AnAh+LiIMaKVK9UsRVtOqds7dR/eH/ZWYW80ev9omIs4DTJ2ySVDvSA0vAV4DHUn0gDUb4nJuZL91bdc6jfm+nUP2tAHwfOJaq5tH3Nbg9uv6bmfmgvV+tJE1njr4NVZ/eSXUQMbhdQt++AvgocBp3fE/j2LcltVJEXAg8cMzdy+1zfxX4Jcrb5/4BsKm+7T63GtP6gCci9gX+jeobrSuArwPPy8xvN1qYihURu5h+p3klZ7flA2eKA6BZ+IEjqTXs21Oxb0tqlRXCnVnZu6UplBDwPAJ4fWY+sb79aoDMfFOjhalYEbHI//S7MnPflTfb+yJiiQWedpmZRZyOJqn7Oty3d7L7299Vs29LapMF9+6lzNxvgc83N/e51WYlzMFzD+CHQ7evqNdJbdCmv6E21SJJbdWmXtmKoEmSCtCmftmmzxFpDyX851wu0Wz3sCNJkqSVLTVdgCQVwn4pTaGEgOcK4F5Dt+9JNSO5NK+ftPS5VmuRtdy+wOeSpNXqat8+d4HPZd+W1DaL7EuL7Jer5T63WquEgOfrwH0i4piIOAB4LvCxhmtS2U6hurLKau2sn6stlntf84x2S+BFq65Gkhank327njD0/EU8FfZtSe3zIhZz5sX5bZlgueY+t1qr9QFPZu4EXgp8FrgE+LvM/FazValkmfle4GTgshkethM4u35M1suT6+dqhZH3NajxBcx28HAZ8II2vS9JWqa/Tbsj/U1a3LcB6otInMSedX5zhqewb0tqpbovvYDZ9rl3Adexux+eNLjYTlu4z602a/1VtKS1EhHPB84EjgK21KsPBy4HzuhCAx55j515X5L6yb4tSeXpQ++WmmLAI0mSJEmSVLjWn6IlSZIkSZKkyQx4JEmSJEmSCmfAI0mSJEmSVDgDHkmSJEmSpMIZ8EiSJEmSJBXOgEeSJEmSJKlwBjySJEmSJEmFM+CRJEmSJEkqnAGPJEmSJElS4Qx4JEmSJEmSCmfAI0mSJEmSVDgDHkmSJEmSpMIZ8EiSJEmSJBXOgEcCIuJFEZFjfn6l6foWJSJOiYjvRsSOevmSpmuSpFF96MkR8eKI+FBEXFa/r7+csO1jI+IfI+KWiLgqIv44Ig5cZrufj4jPRcS2iNgSEe+KiEP37juRpO737Yi4R0S8OSIuiIgbI+LaiPh8RDx6zPa/GhEXRsStEbE5Is6IiDsce0/b36Vp7dd0AVLLPAu4YmTdt5soZNEi4lTgbOC/AV8AngD8RUSQme9stDhJWl5nezLwa8ChwPnAc8dtFBEPBj4LfBJ4LXBv4C3AkcBJQ9vdE/g/wEXArwKH1dvdNyIek5m5V96FJO2pq337F6ne2/8E/gk4EDgd+FJEPCUzPz3YMCL+I/BB4B3A7wC/QLX/vQF4zdB2U/V3aRbh571UfetA1bDvk5nfn+Fx6zJzx14rbEEi4gDgKuAjmfkbQ+v/BngicI/M3NlUfZI0rOs9GSAi9snMXfXvPwY+kZn/eZntPg7cB3jAoE9HxK8D7wIelJnfrNe9neqAYFNm3lSvO54q0H9aZn5sDd6WpJ7qet+uR0P+ZHh/OSL2By4BLs/M44fWXwRck5knDK17A/BK4F6ZeW29bqr+Ls3CU7SkKUXEr9TDTJ8eEe+OiOuAH9X33Tci3lMPwbwlIn4QEWdHxCEjzzHY5mFDwzG/ExFPqu9/RT1c/8aIOC8i7jLy+P0i4jVDp1n9KCL+KCLWrVD+o6i+zX3PyPr/BRwBPGIV/zSStOYK78kMwp0V3uOBVKMtPzASwr8fuB142tC6pwIfH4Q79Wv8PXDlyHaS1IiS+3Zmbh39MjQzbwcuBO4x9PzHAA9g+X3udcCgzln6uzQ1T9GS9rRvRAz/XWRmLo1sczbVUMqTqIZnQtXYL6MajrkV+GngDOBBwOi5uYdSfcPxR1Sjal4HfDgizgWOBU4D7g78D+DPgOcPPfZ9wJOBN1MND70/8AbgKOA5E97X/evlxSPrv1Uv7wf8w4THS1ITutqTp/XTwAGM9O7M3B4Rm6l6NxFxp/o1R3s8VH3+fguoRZKm0Zu+XYdCDwe+PrR63D7394Ed7O7HU/V3aVYGPNKevjNy+/9yxw+Vr2bmbw6vyMwvAl8c3I6IrwKXAl+MiJ/PzIuGNr8z8OTM/Gq97TXABVSJ/gOGhuw/CPitwTD+iPhl4JnASZn53vq5Ph8RNwB/FRH/deR1hh1WL7eOrL9+5H5JapOu9uRpjevdUPXvwf2HrrDd0ausQ5Km1ae+/UaqIOktQ+uW7duZmfXrHDZpu9pwf5dmYsAj7ekZ7Dkx3E+W2ea80RV1gv8K4AVUO9LDs9//DNWklwM3DT6QaoMPws+NDNn/DlWyfwTwY6oPrVuB80a+GTm/Xv7SyOvsUeKM6yWpDbrak6c16NHLTZgYc2wnSXtbL/p2RPxaXe/rRmqxb6tRBjzSni6eYmK4q5ZZ9xbgVOD1VMM9f0L14fRB9vyAgjsm9betsH7w+CPq37ePqevwCTUPRuocClw7tP7QkfslqU262pOnNWmU5aFU325Ps509XtJa6XzfjoinA+8Gzs3MN47cPdyPfzD0mAAOHrp/2v4uzcSAR5rdckn7c4F3Z+aZgxWjk8ItwBaqD6THjrn/ygmPHcy1c3+qy+gODM7v7cLlKyX1U4k9eVrfozpAuT/VQQ4AEbEe2EQ1aSeZ+ZOI+CG7534Ydj+qy/BKUlsU27cj4gnAB6h68unLbDK8zz08N8+9qSZZHuxzT9XfpVl5FS1pMQ6imvF+2IsX/BqfAdYDGzLzX5b5mfSh9BWqbzVOGln/AqoRPf+44FolqUlt78lTycxbgc8Bzxk5neDZwP7Ax4fWfQz4TxFx58GKiHgc1cSlXiJdUtu1vm9HxKOpTi/7LPDC5a6GmJmXUoU8y+1z31Y/dtb+Lk3NETzSYnwW+PWI+DbVcMxnAQ9d5Atk5ucj4oNU5w2/Ffhafdcm4ETg5Zn5gzGPvS0iXge8LSKuBP6e6tKMLwROHb3soyQVrtU9GSAi7g/8XH1zHbApIp5Z3/5iZm6pf/8D4KvA+yLiHKorxPwR8P7M/Nehp/zvVFeK+WhEvJlq2P9b6sca8Ehqu1b37Yi4H/AJ4GrgT4CHVGddDZ46/3lo81dT9eI/B/4O+IV63Vsz85qh7abt79LUDHikxTiN6pKPb6IadvoJquT+nxb8Os8DXkb1jcZrqSaK20z1oXjt+IdBZp4VEbuA/wK8iupSlKdm5l8suEZJalrre3L92NcM3T6h/oFqos+vAGTmBRHxJKr38ingBqrLAw8/lsz8YX2FmLdSfcN8K/BRqgOW5U6HkKQ2aXvffiTVHDoHs+d0BwBLDB1XZ+bHI+I5wO8Dv0EVCr0ROHP4QdP2d2kW4We+JEmSJElS2ZyDR5IkSZIkqXAGPJIkSZIkSYUz4JEkSZIkSSqcAY8kSZIkSVLhDHgkSZIkSZIKZ8AjSZIkSZJUOAMeSZIkSZKkwhnwSJIkSZIkFc6AR5IkSZIkqXD/Hy4VDz4Nqd0WAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x576 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def PlotDispvectorsFrames(srcAnim, srcSurface, tgtAnim, tgtSurface, egoCoord, f1, f2, f3):\n",
    "    %matplotlib inline\n",
    "    fig, axs = plt.subplots(2, 3, figsize=(16,8))\n",
    "    \n",
    "    min_X, max_X = np.inf,np.NINF\n",
    "    min_Y, max_Y = np.inf,np.NINF\n",
    "    for animation, surface, line in zip([srcAnim, tgtAnim],[srcSurface, tgtSurface],range(2)):\n",
    "        for frame, column in zip([f1,f2,f3],range(3)):\n",
    "            aux = animation.getBones(frame)\n",
    "            bones = []\n",
    "            for i in range(len(aux)):\n",
    "                axs[line, column].plot([aux[i,0], aux[i,3]], [aux[i,1], aux[i,4]],'-o', color='black')\n",
    "            surf = []\n",
    "            for triangle in surface.headmesh:\n",
    "                vertices = [[vert.getPosition(animation,frame)[0],vert.getPosition(animation,frame)[1]] for vert in triangle]\n",
    "                vertices.append([triangle[0].getPosition(animation,frame)[0],triangle[0].getPosition(animation,frame)[1]])\n",
    "                vertices = np.asarray(vertices)\n",
    "                axs[line, column].plot(vertices[:,0],vertices[:,1],'-o', color='red', markersize=1, alpha = 0.5)\n",
    "\n",
    "            for triangle in surface.bodymesh:\n",
    "                vertices = [[vert.getPosition(animation,frame)[0],vert.getPosition(animation,frame)[1]] for vert in triangle]\n",
    "                vertices.append([triangle[0].getPosition(animation,frame)[0],triangle[0].getPosition(animation,frame)[1]])\n",
    "                vertices = np.asarray(vertices)\n",
    "                axs[line, column].plot(vertices[:,0],vertices[:,1],'-o', color='red', markersize=1, alpha = 0.5)\n",
    "            mini_X,maxi_X = np.min([aux[:,0].min(),aux[:,3].min()]), np.max([aux[:,0].max(),aux[:,3].max()])\n",
    "            mini_Y, maxi_Y = np.min([aux[:,1].min(),aux[:,4].min()]), np.max([aux[:,1].max(),aux[:,4].max()])\n",
    "            if mini_X<min_X: \n",
    "                min_X=mini_X\n",
    "            if maxi_X>max_X: \n",
    "                max_X=maxi_X\n",
    "            if mini_Y<min_Y: \n",
    "                min_Y=mini_Y\n",
    "            if maxi_Y>max_Y: \n",
    "                max_Y=maxi_Y\n",
    "                \n",
    "    lenNoLimb = len(srcSurface.headmesh)+len(srcSurface.bodymesh)\n",
    "    for frame, column in zip([f1,f2,f3],range(3)):        \n",
    "        dispvector = np.asarray([np.asarray(egoCoord.framecoord[frame].dispvector[i]*egoCoord.framecoord[frame].tau[i])+egoCoord.framecoord[frame].refpoint[i] for i in range(lenNoLimb)])\n",
    "        refpoint = np.asarray(egoCoord.framecoord[frame].refpoint[:lenNoLimb])\n",
    "        norm_importance = egoCoord.framecoord[frame].importance/egoCoord.framecoord[frame].importance.max()\n",
    "        for i in range(lenNoLimb):\n",
    "            axs[0, column].plot([refpoint[i,0],dispvector[i,0]],[refpoint[i,1],dispvector[i,1]], color=[1*(1-norm_importance[i]),1*(1-norm_importance[i]),1])\n",
    "        dispvector = np.asarray([np.asarray(egoCoord.framecoord[frame].tgt_dispvector[i])+egoCoord.framecoord[frame].tgt_refpoint[i] for i in range(lenNoLimb)])\n",
    "        refpoint = np.asarray(egoCoord.framecoord[frame].tgt_refpoint[:lenNoLimb])\n",
    "        norm_importance = egoCoord.framecoord[frame].importance/egoCoord.framecoord[frame].importance.max()\n",
    "        for i in range(lenNoLimb):\n",
    "            axs[1, column].plot([refpoint[i,0],dispvector[i,0]],[refpoint[i,1],dispvector[i,1]], color=[1*(1-norm_importance[i]),1*(1-norm_importance[i]),1])\n",
    "    for line in range(2):\n",
    "        for column in range(3):\n",
    "            axs[line, column].set_xlim(min_X-5,max_X+5)\n",
    "            axs[line, column].set_ylim(min_Y-10,max_Y+10)\n",
    "            axs[line, column].set_frame_on(False)\n",
    "            axs[line, column].tick_params(axis='both', which='both', length=0)\n",
    "            axs[line, column].set_xticks([])\n",
    "            if column!=0:\n",
    "                axs[line, column].set_yticks([])\n",
    "            #axs[line, column].set_axis_off()\n",
    "    frames = [f1,f2,f3]\n",
    "    font_size = 16\n",
    "    for column in range(3):\n",
    "        axs[1,column].set_xlabel(str.format('Frame %i' % frames[column]), fontsize=font_size)\n",
    "        \n",
    "    axs[0,0].set_ylabel('Source', fontsize=font_size)\n",
    "    axs[1,0].set_ylabel('Target', fontsize=font_size)\n",
    "    \n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "PlotDispvectorsFrames(sourceAnimation, sourceSurface, targetAnimation, targetSurface, egoCoords[0], 0, 100,200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pose Adaptation\n",
    "\n",
    "(Em construção)\n",
    "\n",
    "## Inverse Kinematics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Results\n",
    "\n",
    "(Em construção)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "(Em construção)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Future Works\n",
    "\n",
    "(Em construção)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
